// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/vizier/messages/messagespb/messages.proto

package messagespb

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
	uuidpb "px.dev/pixie/src/api/proto/uuidpb"
	distributedpb "px.dev/pixie/src/carnot/planner/distributedpb"
	logicalpb "px.dev/pixie/src/carnot/planner/dynamic_tracing/ir/logicalpb"
	planpb "px.dev/pixie/src/carnot/planpb"
	statuspb "px.dev/pixie/src/common/base/statuspb"
	metadatapb "px.dev/pixie/src/shared/k8s/metadatapb"
	storepb "px.dev/pixie/src/vizier/services/metadata/storepb"
	agentpb "px.dev/pixie/src/vizier/services/shared/agentpb"
	reflect "reflect"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type VizierMessage struct {
	// Types that are valid to be assigned to Msg:
	//	*VizierMessage_RegisterAgentRequest
	//	*VizierMessage_RegisterAgentResponse
	//	*VizierMessage_Heartbeat
	//	*VizierMessage_HeartbeatAck
	//	*VizierMessage_HeartbeatNack
	//	*VizierMessage_ExecuteQueryRequest
	//	*VizierMessage_TracepointMessage
	//	*VizierMessage_ConfigUpdateMessage
	//	*VizierMessage_K8SMetadataMessage
	Msg isVizierMessage_Msg `protobuf_oneof:"msg"`
}

func (m *VizierMessage) Reset()      { *m = VizierMessage{} }
func (*VizierMessage) ProtoMessage() {}
func (*VizierMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{0}
}
func (m *VizierMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *VizierMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_VizierMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *VizierMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VizierMessage.Merge(m, src)
}
func (m *VizierMessage) XXX_Size() int {
	return m.Size()
}
func (m *VizierMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_VizierMessage.DiscardUnknown(m)
}

var xxx_messageInfo_VizierMessage proto.InternalMessageInfo

type isVizierMessage_Msg interface {
	isVizierMessage_Msg()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type VizierMessage_RegisterAgentRequest struct {
	RegisterAgentRequest *RegisterAgentRequest `protobuf:"bytes,1,opt,name=register_agent_request,json=registerAgentRequest,proto3,oneof" json:"register_agent_request,omitempty"`
}
type VizierMessage_RegisterAgentResponse struct {
	RegisterAgentResponse *RegisterAgentResponse `protobuf:"bytes,2,opt,name=register_agent_response,json=registerAgentResponse,proto3,oneof" json:"register_agent_response,omitempty"`
}
type VizierMessage_Heartbeat struct {
	Heartbeat *Heartbeat `protobuf:"bytes,5,opt,name=heartbeat,proto3,oneof" json:"heartbeat,omitempty"`
}
type VizierMessage_HeartbeatAck struct {
	HeartbeatAck *HeartbeatAck `protobuf:"bytes,6,opt,name=heartbeat_ack,json=heartbeatAck,proto3,oneof" json:"heartbeat_ack,omitempty"`
}
type VizierMessage_HeartbeatNack struct {
	HeartbeatNack *HeartbeatNack `protobuf:"bytes,7,opt,name=heartbeat_nack,json=heartbeatNack,proto3,oneof" json:"heartbeat_nack,omitempty"`
}
type VizierMessage_ExecuteQueryRequest struct {
	ExecuteQueryRequest *ExecuteQueryRequest `protobuf:"bytes,8,opt,name=execute_query_request,json=executeQueryRequest,proto3,oneof" json:"execute_query_request,omitempty"`
}
type VizierMessage_TracepointMessage struct {
	TracepointMessage *TracepointMessage `protobuf:"bytes,10,opt,name=tracepoint_message,json=tracepointMessage,proto3,oneof" json:"tracepoint_message,omitempty"`
}
type VizierMessage_ConfigUpdateMessage struct {
	ConfigUpdateMessage *ConfigUpdateMessage `protobuf:"bytes,11,opt,name=config_update_message,json=configUpdateMessage,proto3,oneof" json:"config_update_message,omitempty"`
}
type VizierMessage_K8SMetadataMessage struct {
	K8SMetadataMessage *K8SMetadataMessage `protobuf:"bytes,12,opt,name=k8s_metadata_message,json=k8sMetadataMessage,proto3,oneof" json:"k8s_metadata_message,omitempty"`
}

func (*VizierMessage_RegisterAgentRequest) isVizierMessage_Msg()  {}
func (*VizierMessage_RegisterAgentResponse) isVizierMessage_Msg() {}
func (*VizierMessage_Heartbeat) isVizierMessage_Msg()             {}
func (*VizierMessage_HeartbeatAck) isVizierMessage_Msg()          {}
func (*VizierMessage_HeartbeatNack) isVizierMessage_Msg()         {}
func (*VizierMessage_ExecuteQueryRequest) isVizierMessage_Msg()   {}
func (*VizierMessage_TracepointMessage) isVizierMessage_Msg()     {}
func (*VizierMessage_ConfigUpdateMessage) isVizierMessage_Msg()   {}
func (*VizierMessage_K8SMetadataMessage) isVizierMessage_Msg()    {}

func (m *VizierMessage) GetMsg() isVizierMessage_Msg {
	if m != nil {
		return m.Msg
	}
	return nil
}

func (m *VizierMessage) GetRegisterAgentRequest() *RegisterAgentRequest {
	if x, ok := m.GetMsg().(*VizierMessage_RegisterAgentRequest); ok {
		return x.RegisterAgentRequest
	}
	return nil
}

func (m *VizierMessage) GetRegisterAgentResponse() *RegisterAgentResponse {
	if x, ok := m.GetMsg().(*VizierMessage_RegisterAgentResponse); ok {
		return x.RegisterAgentResponse
	}
	return nil
}

func (m *VizierMessage) GetHeartbeat() *Heartbeat {
	if x, ok := m.GetMsg().(*VizierMessage_Heartbeat); ok {
		return x.Heartbeat
	}
	return nil
}

func (m *VizierMessage) GetHeartbeatAck() *HeartbeatAck {
	if x, ok := m.GetMsg().(*VizierMessage_HeartbeatAck); ok {
		return x.HeartbeatAck
	}
	return nil
}

func (m *VizierMessage) GetHeartbeatNack() *HeartbeatNack {
	if x, ok := m.GetMsg().(*VizierMessage_HeartbeatNack); ok {
		return x.HeartbeatNack
	}
	return nil
}

func (m *VizierMessage) GetExecuteQueryRequest() *ExecuteQueryRequest {
	if x, ok := m.GetMsg().(*VizierMessage_ExecuteQueryRequest); ok {
		return x.ExecuteQueryRequest
	}
	return nil
}

func (m *VizierMessage) GetTracepointMessage() *TracepointMessage {
	if x, ok := m.GetMsg().(*VizierMessage_TracepointMessage); ok {
		return x.TracepointMessage
	}
	return nil
}

func (m *VizierMessage) GetConfigUpdateMessage() *ConfigUpdateMessage {
	if x, ok := m.GetMsg().(*VizierMessage_ConfigUpdateMessage); ok {
		return x.ConfigUpdateMessage
	}
	return nil
}

func (m *VizierMessage) GetK8SMetadataMessage() *K8SMetadataMessage {
	if x, ok := m.GetMsg().(*VizierMessage_K8SMetadataMessage); ok {
		return x.K8SMetadataMessage
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*VizierMessage) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*VizierMessage_RegisterAgentRequest)(nil),
		(*VizierMessage_RegisterAgentResponse)(nil),
		(*VizierMessage_Heartbeat)(nil),
		(*VizierMessage_HeartbeatAck)(nil),
		(*VizierMessage_HeartbeatNack)(nil),
		(*VizierMessage_ExecuteQueryRequest)(nil),
		(*VizierMessage_TracepointMessage)(nil),
		(*VizierMessage_ConfigUpdateMessage)(nil),
		(*VizierMessage_K8SMetadataMessage)(nil),
	}
}

type TracepointMessage struct {
	// Types that are valid to be assigned to Msg:
	//	*TracepointMessage_TracepointInfoUpdate
	//	*TracepointMessage_RemoveTracepointRequest
	//	*TracepointMessage_RegisterTracepointRequest
	Msg isTracepointMessage_Msg `protobuf_oneof:"msg"`
}

func (m *TracepointMessage) Reset()      { *m = TracepointMessage{} }
func (*TracepointMessage) ProtoMessage() {}
func (*TracepointMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{1}
}
func (m *TracepointMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TracepointMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TracepointMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TracepointMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TracepointMessage.Merge(m, src)
}
func (m *TracepointMessage) XXX_Size() int {
	return m.Size()
}
func (m *TracepointMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_TracepointMessage.DiscardUnknown(m)
}

var xxx_messageInfo_TracepointMessage proto.InternalMessageInfo

type isTracepointMessage_Msg interface {
	isTracepointMessage_Msg()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type TracepointMessage_TracepointInfoUpdate struct {
	TracepointInfoUpdate *TracepointInfoUpdate `protobuf:"bytes,1,opt,name=tracepoint_info_update,json=tracepointInfoUpdate,proto3,oneof" json:"tracepoint_info_update,omitempty"`
}
type TracepointMessage_RemoveTracepointRequest struct {
	RemoveTracepointRequest *RemoveTracepointRequest `protobuf:"bytes,2,opt,name=remove_tracepoint_request,json=removeTracepointRequest,proto3,oneof" json:"remove_tracepoint_request,omitempty"`
}
type TracepointMessage_RegisterTracepointRequest struct {
	RegisterTracepointRequest *RegisterTracepointRequest `protobuf:"bytes,3,opt,name=register_tracepoint_request,json=registerTracepointRequest,proto3,oneof" json:"register_tracepoint_request,omitempty"`
}

func (*TracepointMessage_TracepointInfoUpdate) isTracepointMessage_Msg()      {}
func (*TracepointMessage_RemoveTracepointRequest) isTracepointMessage_Msg()   {}
func (*TracepointMessage_RegisterTracepointRequest) isTracepointMessage_Msg() {}

func (m *TracepointMessage) GetMsg() isTracepointMessage_Msg {
	if m != nil {
		return m.Msg
	}
	return nil
}

func (m *TracepointMessage) GetTracepointInfoUpdate() *TracepointInfoUpdate {
	if x, ok := m.GetMsg().(*TracepointMessage_TracepointInfoUpdate); ok {
		return x.TracepointInfoUpdate
	}
	return nil
}

func (m *TracepointMessage) GetRemoveTracepointRequest() *RemoveTracepointRequest {
	if x, ok := m.GetMsg().(*TracepointMessage_RemoveTracepointRequest); ok {
		return x.RemoveTracepointRequest
	}
	return nil
}

func (m *TracepointMessage) GetRegisterTracepointRequest() *RegisterTracepointRequest {
	if x, ok := m.GetMsg().(*TracepointMessage_RegisterTracepointRequest); ok {
		return x.RegisterTracepointRequest
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*TracepointMessage) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*TracepointMessage_TracepointInfoUpdate)(nil),
		(*TracepointMessage_RemoveTracepointRequest)(nil),
		(*TracepointMessage_RegisterTracepointRequest)(nil),
	}
}

type ConfigUpdateMessage struct {
	// Types that are valid to be assigned to Msg:
	//	*ConfigUpdateMessage_ConfigUpdateRequest
	Msg isConfigUpdateMessage_Msg `protobuf_oneof:"msg"`
}

func (m *ConfigUpdateMessage) Reset()      { *m = ConfigUpdateMessage{} }
func (*ConfigUpdateMessage) ProtoMessage() {}
func (*ConfigUpdateMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{2}
}
func (m *ConfigUpdateMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConfigUpdateMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConfigUpdateMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConfigUpdateMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfigUpdateMessage.Merge(m, src)
}
func (m *ConfigUpdateMessage) XXX_Size() int {
	return m.Size()
}
func (m *ConfigUpdateMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfigUpdateMessage.DiscardUnknown(m)
}

var xxx_messageInfo_ConfigUpdateMessage proto.InternalMessageInfo

type isConfigUpdateMessage_Msg interface {
	isConfigUpdateMessage_Msg()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type ConfigUpdateMessage_ConfigUpdateRequest struct {
	ConfigUpdateRequest *ConfigUpdateRequest `protobuf:"bytes,1,opt,name=config_update_request,json=configUpdateRequest,proto3,oneof" json:"config_update_request,omitempty"`
}

func (*ConfigUpdateMessage_ConfigUpdateRequest) isConfigUpdateMessage_Msg() {}

func (m *ConfigUpdateMessage) GetMsg() isConfigUpdateMessage_Msg {
	if m != nil {
		return m.Msg
	}
	return nil
}

func (m *ConfigUpdateMessage) GetConfigUpdateRequest() *ConfigUpdateRequest {
	if x, ok := m.GetMsg().(*ConfigUpdateMessage_ConfigUpdateRequest); ok {
		return x.ConfigUpdateRequest
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ConfigUpdateMessage) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ConfigUpdateMessage_ConfigUpdateRequest)(nil),
	}
}

type K8SMetadataMessage struct {
	// Types that are valid to be assigned to Msg:
	//	*K8SMetadataMessage_K8SMetadataUpdate
	//	*K8SMetadataMessage_MissingK8SMetadataRequest
	//	*K8SMetadataMessage_MissingK8SMetadataResponse
	Msg isK8SMetadataMessage_Msg `protobuf_oneof:"msg"`
}

func (m *K8SMetadataMessage) Reset()      { *m = K8SMetadataMessage{} }
func (*K8SMetadataMessage) ProtoMessage() {}
func (*K8SMetadataMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{3}
}
func (m *K8SMetadataMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *K8SMetadataMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_K8SMetadataMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *K8SMetadataMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_K8SMetadataMessage.Merge(m, src)
}
func (m *K8SMetadataMessage) XXX_Size() int {
	return m.Size()
}
func (m *K8SMetadataMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_K8SMetadataMessage.DiscardUnknown(m)
}

var xxx_messageInfo_K8SMetadataMessage proto.InternalMessageInfo

type isK8SMetadataMessage_Msg interface {
	isK8SMetadataMessage_Msg()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type K8SMetadataMessage_K8SMetadataUpdate struct {
	K8SMetadataUpdate *metadatapb.ResourceUpdate `protobuf:"bytes,1,opt,name=k8s_metadata_update,json=k8sMetadataUpdate,proto3,oneof" json:"k8s_metadata_update,omitempty"`
}
type K8SMetadataMessage_MissingK8SMetadataRequest struct {
	MissingK8SMetadataRequest *metadatapb.MissingK8SMetadataRequest `protobuf:"bytes,2,opt,name=missing_k8s_metadata_request,json=missingK8sMetadataRequest,proto3,oneof" json:"missing_k8s_metadata_request,omitempty"`
}
type K8SMetadataMessage_MissingK8SMetadataResponse struct {
	MissingK8SMetadataResponse *metadatapb.MissingK8SMetadataResponse `protobuf:"bytes,3,opt,name=missing_k8s_metadata_response,json=missingK8sMetadataResponse,proto3,oneof" json:"missing_k8s_metadata_response,omitempty"`
}

func (*K8SMetadataMessage_K8SMetadataUpdate) isK8SMetadataMessage_Msg()          {}
func (*K8SMetadataMessage_MissingK8SMetadataRequest) isK8SMetadataMessage_Msg()  {}
func (*K8SMetadataMessage_MissingK8SMetadataResponse) isK8SMetadataMessage_Msg() {}

func (m *K8SMetadataMessage) GetMsg() isK8SMetadataMessage_Msg {
	if m != nil {
		return m.Msg
	}
	return nil
}

func (m *K8SMetadataMessage) GetK8SMetadataUpdate() *metadatapb.ResourceUpdate {
	if x, ok := m.GetMsg().(*K8SMetadataMessage_K8SMetadataUpdate); ok {
		return x.K8SMetadataUpdate
	}
	return nil
}

func (m *K8SMetadataMessage) GetMissingK8SMetadataRequest() *metadatapb.MissingK8SMetadataRequest {
	if x, ok := m.GetMsg().(*K8SMetadataMessage_MissingK8SMetadataRequest); ok {
		return x.MissingK8SMetadataRequest
	}
	return nil
}

func (m *K8SMetadataMessage) GetMissingK8SMetadataResponse() *metadatapb.MissingK8SMetadataResponse {
	if x, ok := m.GetMsg().(*K8SMetadataMessage_MissingK8SMetadataResponse); ok {
		return x.MissingK8SMetadataResponse
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*K8SMetadataMessage) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*K8SMetadataMessage_K8SMetadataUpdate)(nil),
		(*K8SMetadataMessage_MissingK8SMetadataRequest)(nil),
		(*K8SMetadataMessage_MissingK8SMetadataResponse)(nil),
	}
}

type RegisterAgentRequest struct {
	Info *agentpb.AgentInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
	ASID uint32             `protobuf:"varint,3,opt,name=asid,proto3" json:"asid,omitempty"`
}

func (m *RegisterAgentRequest) Reset()      { *m = RegisterAgentRequest{} }
func (*RegisterAgentRequest) ProtoMessage() {}
func (*RegisterAgentRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{4}
}
func (m *RegisterAgentRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterAgentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterAgentRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterAgentRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterAgentRequest.Merge(m, src)
}
func (m *RegisterAgentRequest) XXX_Size() int {
	return m.Size()
}
func (m *RegisterAgentRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterAgentRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterAgentRequest proto.InternalMessageInfo

func (m *RegisterAgentRequest) GetInfo() *agentpb.AgentInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

func (m *RegisterAgentRequest) GetASID() uint32 {
	if m != nil {
		return m.ASID
	}
	return 0
}

type RegisterAgentResponse struct {
	ASID uint32 `protobuf:"varint,1,opt,name=asid,proto3" json:"asid,omitempty"`
}

func (m *RegisterAgentResponse) Reset()      { *m = RegisterAgentResponse{} }
func (*RegisterAgentResponse) ProtoMessage() {}
func (*RegisterAgentResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{5}
}
func (m *RegisterAgentResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterAgentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterAgentResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterAgentResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterAgentResponse.Merge(m, src)
}
func (m *RegisterAgentResponse) XXX_Size() int {
	return m.Size()
}
func (m *RegisterAgentResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterAgentResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterAgentResponse proto.InternalMessageInfo

func (m *RegisterAgentResponse) GetASID() uint32 {
	if m != nil {
		return m.ASID
	}
	return 0
}

type AgentDataInfo struct {
	MetadataInfo *distributedpb.MetadataInfo `protobuf:"bytes,1,opt,name=metadata_info,json=metadataInfo,proto3" json:"metadata_info,omitempty"`
}

func (m *AgentDataInfo) Reset()      { *m = AgentDataInfo{} }
func (*AgentDataInfo) ProtoMessage() {}
func (*AgentDataInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{6}
}
func (m *AgentDataInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentDataInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentDataInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentDataInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentDataInfo.Merge(m, src)
}
func (m *AgentDataInfo) XXX_Size() int {
	return m.Size()
}
func (m *AgentDataInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentDataInfo.DiscardUnknown(m)
}

var xxx_messageInfo_AgentDataInfo proto.InternalMessageInfo

func (m *AgentDataInfo) GetMetadataInfo() *distributedpb.MetadataInfo {
	if m != nil {
		return m.MetadataInfo
	}
	return nil
}

type AgentUpdateInfo struct {
	Schema            []*storepb.TableInfo            `protobuf:"bytes,2,rep,name=schema,proto3" json:"schema,omitempty"`
	ProcessCreated    []*metadatapb.ProcessCreated    `protobuf:"bytes,4,rep,name=process_created,json=processCreated,proto3" json:"process_created,omitempty"`
	ProcessTerminated []*metadatapb.ProcessTerminated `protobuf:"bytes,5,rep,name=process_terminated,json=processTerminated,proto3" json:"process_terminated,omitempty"`
	DoesUpdateSchema  bool                            `protobuf:"varint,6,opt,name=does_update_schema,json=doesUpdateSchema,proto3" json:"does_update_schema,omitempty"`
	Data              *AgentDataInfo                  `protobuf:"bytes,7,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *AgentUpdateInfo) Reset()      { *m = AgentUpdateInfo{} }
func (*AgentUpdateInfo) ProtoMessage() {}
func (*AgentUpdateInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{7}
}
func (m *AgentUpdateInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentUpdateInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentUpdateInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentUpdateInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentUpdateInfo.Merge(m, src)
}
func (m *AgentUpdateInfo) XXX_Size() int {
	return m.Size()
}
func (m *AgentUpdateInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentUpdateInfo.DiscardUnknown(m)
}

var xxx_messageInfo_AgentUpdateInfo proto.InternalMessageInfo

func (m *AgentUpdateInfo) GetSchema() []*storepb.TableInfo {
	if m != nil {
		return m.Schema
	}
	return nil
}

func (m *AgentUpdateInfo) GetProcessCreated() []*metadatapb.ProcessCreated {
	if m != nil {
		return m.ProcessCreated
	}
	return nil
}

func (m *AgentUpdateInfo) GetProcessTerminated() []*metadatapb.ProcessTerminated {
	if m != nil {
		return m.ProcessTerminated
	}
	return nil
}

func (m *AgentUpdateInfo) GetDoesUpdateSchema() bool {
	if m != nil {
		return m.DoesUpdateSchema
	}
	return false
}

func (m *AgentUpdateInfo) GetData() *AgentDataInfo {
	if m != nil {
		return m.Data
	}
	return nil
}

type Heartbeat struct {
	AgentID        *uuidpb.UUID     `protobuf:"bytes,1,opt,name=agent_id,json=agentId,proto3" json:"agent_id,omitempty"`
	Time           int64            `protobuf:"varint,2,opt,name=time,proto3" json:"time,omitempty"`
	UpdateInfo     *AgentUpdateInfo `protobuf:"bytes,3,opt,name=update_info,json=updateInfo,proto3" json:"update_info,omitempty"`
	SequenceNumber int64            `protobuf:"varint,4,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"`
}

func (m *Heartbeat) Reset()      { *m = Heartbeat{} }
func (*Heartbeat) ProtoMessage() {}
func (*Heartbeat) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{8}
}
func (m *Heartbeat) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Heartbeat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Heartbeat.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Heartbeat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Heartbeat.Merge(m, src)
}
func (m *Heartbeat) XXX_Size() int {
	return m.Size()
}
func (m *Heartbeat) XXX_DiscardUnknown() {
	xxx_messageInfo_Heartbeat.DiscardUnknown(m)
}

var xxx_messageInfo_Heartbeat proto.InternalMessageInfo

func (m *Heartbeat) GetAgentID() *uuidpb.UUID {
	if m != nil {
		return m.AgentID
	}
	return nil
}

func (m *Heartbeat) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *Heartbeat) GetUpdateInfo() *AgentUpdateInfo {
	if m != nil {
		return m.UpdateInfo
	}
	return nil
}

func (m *Heartbeat) GetSequenceNumber() int64 {
	if m != nil {
		return m.SequenceNumber
	}
	return 0
}

type MetadataUpdateInfo struct {
	ServiceCIDR string   `protobuf:"bytes,2,opt,name=service_cidr,json=serviceCidr,proto3" json:"service_cidr,omitempty"`
	PodCIDRs    []string `protobuf:"bytes,3,rep,name=pod_cidrs,json=podCidrs,proto3" json:"pod_cidrs,omitempty"`
}

func (m *MetadataUpdateInfo) Reset()      { *m = MetadataUpdateInfo{} }
func (*MetadataUpdateInfo) ProtoMessage() {}
func (*MetadataUpdateInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{9}
}
func (m *MetadataUpdateInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MetadataUpdateInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MetadataUpdateInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MetadataUpdateInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetadataUpdateInfo.Merge(m, src)
}
func (m *MetadataUpdateInfo) XXX_Size() int {
	return m.Size()
}
func (m *MetadataUpdateInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_MetadataUpdateInfo.DiscardUnknown(m)
}

var xxx_messageInfo_MetadataUpdateInfo proto.InternalMessageInfo

func (m *MetadataUpdateInfo) GetServiceCIDR() string {
	if m != nil {
		return m.ServiceCIDR
	}
	return ""
}

func (m *MetadataUpdateInfo) GetPodCIDRs() []string {
	if m != nil {
		return m.PodCIDRs
	}
	return nil
}

type HeartbeatAck struct {
	Time           int64               `protobuf:"varint,1,opt,name=time,proto3" json:"time,omitempty"`
	SequenceNumber int64               `protobuf:"varint,2,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"`
	UpdateInfo     *MetadataUpdateInfo `protobuf:"bytes,3,opt,name=update_info,json=updateInfo,proto3" json:"update_info,omitempty"`
}

func (m *HeartbeatAck) Reset()      { *m = HeartbeatAck{} }
func (*HeartbeatAck) ProtoMessage() {}
func (*HeartbeatAck) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{10}
}
func (m *HeartbeatAck) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HeartbeatAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HeartbeatAck.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HeartbeatAck) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeartbeatAck.Merge(m, src)
}
func (m *HeartbeatAck) XXX_Size() int {
	return m.Size()
}
func (m *HeartbeatAck) XXX_DiscardUnknown() {
	xxx_messageInfo_HeartbeatAck.DiscardUnknown(m)
}

var xxx_messageInfo_HeartbeatAck proto.InternalMessageInfo

func (m *HeartbeatAck) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *HeartbeatAck) GetSequenceNumber() int64 {
	if m != nil {
		return m.SequenceNumber
	}
	return 0
}

func (m *HeartbeatAck) GetUpdateInfo() *MetadataUpdateInfo {
	if m != nil {
		return m.UpdateInfo
	}
	return nil
}

type HeartbeatNack struct {
	Reregister bool `protobuf:"varint,1,opt,name=reregister,proto3" json:"reregister,omitempty"`
}

func (m *HeartbeatNack) Reset()      { *m = HeartbeatNack{} }
func (*HeartbeatNack) ProtoMessage() {}
func (*HeartbeatNack) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{11}
}
func (m *HeartbeatNack) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HeartbeatNack) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HeartbeatNack.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HeartbeatNack) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HeartbeatNack.Merge(m, src)
}
func (m *HeartbeatNack) XXX_Size() int {
	return m.Size()
}
func (m *HeartbeatNack) XXX_DiscardUnknown() {
	xxx_messageInfo_HeartbeatNack.DiscardUnknown(m)
}

var xxx_messageInfo_HeartbeatNack proto.InternalMessageInfo

func (m *HeartbeatNack) GetReregister() bool {
	if m != nil {
		return m.Reregister
	}
	return false
}

type ExecuteQueryRequest struct {
	QueryID *uuidpb.UUID `protobuf:"bytes,1,opt,name=query_id,json=queryId,proto3" json:"query_id,omitempty"`
	Plan    *planpb.Plan `protobuf:"bytes,3,opt,name=plan,proto3" json:"plan,omitempty"`
	Analyze bool         `protobuf:"varint,4,opt,name=analyze,proto3" json:"analyze,omitempty"`
}

func (m *ExecuteQueryRequest) Reset()      { *m = ExecuteQueryRequest{} }
func (*ExecuteQueryRequest) ProtoMessage() {}
func (*ExecuteQueryRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{12}
}
func (m *ExecuteQueryRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExecuteQueryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExecuteQueryRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExecuteQueryRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteQueryRequest.Merge(m, src)
}
func (m *ExecuteQueryRequest) XXX_Size() int {
	return m.Size()
}
func (m *ExecuteQueryRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteQueryRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteQueryRequest proto.InternalMessageInfo

func (m *ExecuteQueryRequest) GetQueryID() *uuidpb.UUID {
	if m != nil {
		return m.QueryID
	}
	return nil
}

func (m *ExecuteQueryRequest) GetPlan() *planpb.Plan {
	if m != nil {
		return m.Plan
	}
	return nil
}

func (m *ExecuteQueryRequest) GetAnalyze() bool {
	if m != nil {
		return m.Analyze
	}
	return false
}

type RegisterTracepointRequest struct {
	TracepointDeployment *logicalpb.TracepointDeployment `protobuf:"bytes,1,opt,name=tracepoint_deployment,json=tracepointDeployment,proto3" json:"tracepoint_deployment,omitempty"`
	ID                   *uuidpb.UUID                    `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *RegisterTracepointRequest) Reset()      { *m = RegisterTracepointRequest{} }
func (*RegisterTracepointRequest) ProtoMessage() {}
func (*RegisterTracepointRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{13}
}
func (m *RegisterTracepointRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterTracepointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterTracepointRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterTracepointRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterTracepointRequest.Merge(m, src)
}
func (m *RegisterTracepointRequest) XXX_Size() int {
	return m.Size()
}
func (m *RegisterTracepointRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterTracepointRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterTracepointRequest proto.InternalMessageInfo

func (m *RegisterTracepointRequest) GetTracepointDeployment() *logicalpb.TracepointDeployment {
	if m != nil {
		return m.TracepointDeployment
	}
	return nil
}

func (m *RegisterTracepointRequest) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

type TracepointInfoUpdate struct {
	ID      *uuidpb.UUID            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	State   statuspb.LifeCycleState `protobuf:"varint,2,opt,name=state,proto3,enum=px.statuspb.LifeCycleState" json:"state,omitempty"`
	Status  *statuspb.Status        `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	AgentID *uuidpb.UUID            `protobuf:"bytes,4,opt,name=agent_id,json=agentId,proto3" json:"agent_id,omitempty"`
}

func (m *TracepointInfoUpdate) Reset()      { *m = TracepointInfoUpdate{} }
func (*TracepointInfoUpdate) ProtoMessage() {}
func (*TracepointInfoUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{14}
}
func (m *TracepointInfoUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TracepointInfoUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TracepointInfoUpdate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TracepointInfoUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TracepointInfoUpdate.Merge(m, src)
}
func (m *TracepointInfoUpdate) XXX_Size() int {
	return m.Size()
}
func (m *TracepointInfoUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_TracepointInfoUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_TracepointInfoUpdate proto.InternalMessageInfo

func (m *TracepointInfoUpdate) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *TracepointInfoUpdate) GetState() statuspb.LifeCycleState {
	if m != nil {
		return m.State
	}
	return statuspb.UNKNOWN_STATE
}

func (m *TracepointInfoUpdate) GetStatus() *statuspb.Status {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *TracepointInfoUpdate) GetAgentID() *uuidpb.UUID {
	if m != nil {
		return m.AgentID
	}
	return nil
}

type RemoveTracepointRequest struct {
	ID *uuidpb.UUID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *RemoveTracepointRequest) Reset()      { *m = RemoveTracepointRequest{} }
func (*RemoveTracepointRequest) ProtoMessage() {}
func (*RemoveTracepointRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{15}
}
func (m *RemoveTracepointRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RemoveTracepointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RemoveTracepointRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RemoveTracepointRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RemoveTracepointRequest.Merge(m, src)
}
func (m *RemoveTracepointRequest) XXX_Size() int {
	return m.Size()
}
func (m *RemoveTracepointRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RemoveTracepointRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RemoveTracepointRequest proto.InternalMessageInfo

func (m *RemoveTracepointRequest) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

type ConfigUpdateRequest struct {
	Key   string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *ConfigUpdateRequest) Reset()      { *m = ConfigUpdateRequest{} }
func (*ConfigUpdateRequest) ProtoMessage() {}
func (*ConfigUpdateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{16}
}
func (m *ConfigUpdateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConfigUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConfigUpdateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConfigUpdateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfigUpdateRequest.Merge(m, src)
}
func (m *ConfigUpdateRequest) XXX_Size() int {
	return m.Size()
}
func (m *ConfigUpdateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfigUpdateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ConfigUpdateRequest proto.InternalMessageInfo

func (m *ConfigUpdateRequest) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *ConfigUpdateRequest) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type MetricsMessage struct {
	PromMetricsText string `protobuf:"bytes,1,opt,name=prom_metrics_text,json=promMetricsText,proto3" json:"prom_metrics_text,omitempty"`
	PodName         string `protobuf:"bytes,2,opt,name=pod_name,json=podName,proto3" json:"pod_name,omitempty"`
}

func (m *MetricsMessage) Reset()      { *m = MetricsMessage{} }
func (*MetricsMessage) ProtoMessage() {}
func (*MetricsMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_0046fd1b9991f89c, []int{17}
}
func (m *MetricsMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MetricsMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MetricsMessage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MetricsMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetricsMessage.Merge(m, src)
}
func (m *MetricsMessage) XXX_Size() int {
	return m.Size()
}
func (m *MetricsMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_MetricsMessage.DiscardUnknown(m)
}

var xxx_messageInfo_MetricsMessage proto.InternalMessageInfo

func (m *MetricsMessage) GetPromMetricsText() string {
	if m != nil {
		return m.PromMetricsText
	}
	return ""
}

func (m *MetricsMessage) GetPodName() string {
	if m != nil {
		return m.PodName
	}
	return ""
}

func init() {
	proto.RegisterType((*VizierMessage)(nil), "px.vizier.messages.VizierMessage")
	proto.RegisterType((*TracepointMessage)(nil), "px.vizier.messages.TracepointMessage")
	proto.RegisterType((*ConfigUpdateMessage)(nil), "px.vizier.messages.ConfigUpdateMessage")
	proto.RegisterType((*K8SMetadataMessage)(nil), "px.vizier.messages.K8sMetadataMessage")
	proto.RegisterType((*RegisterAgentRequest)(nil), "px.vizier.messages.RegisterAgentRequest")
	proto.RegisterType((*RegisterAgentResponse)(nil), "px.vizier.messages.RegisterAgentResponse")
	proto.RegisterType((*AgentDataInfo)(nil), "px.vizier.messages.AgentDataInfo")
	proto.RegisterType((*AgentUpdateInfo)(nil), "px.vizier.messages.AgentUpdateInfo")
	proto.RegisterType((*Heartbeat)(nil), "px.vizier.messages.Heartbeat")
	proto.RegisterType((*MetadataUpdateInfo)(nil), "px.vizier.messages.MetadataUpdateInfo")
	proto.RegisterType((*HeartbeatAck)(nil), "px.vizier.messages.HeartbeatAck")
	proto.RegisterType((*HeartbeatNack)(nil), "px.vizier.messages.HeartbeatNack")
	proto.RegisterType((*ExecuteQueryRequest)(nil), "px.vizier.messages.ExecuteQueryRequest")
	proto.RegisterType((*RegisterTracepointRequest)(nil), "px.vizier.messages.RegisterTracepointRequest")
	proto.RegisterType((*TracepointInfoUpdate)(nil), "px.vizier.messages.TracepointInfoUpdate")
	proto.RegisterType((*RemoveTracepointRequest)(nil), "px.vizier.messages.RemoveTracepointRequest")
	proto.RegisterType((*ConfigUpdateRequest)(nil), "px.vizier.messages.ConfigUpdateRequest")
	proto.RegisterType((*MetricsMessage)(nil), "px.vizier.messages.MetricsMessage")
}

func init() {
	proto.RegisterFile("src/vizier/messages/messagespb/messages.proto", fileDescriptor_0046fd1b9991f89c)
}

var fileDescriptor_0046fd1b9991f89c = []byte{
	// 1559 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x58, 0x49, 0x6f, 0x1b, 0x47,
	0x16, 0x66, 0x93, 0x94, 0x44, 0x3d, 0xed, 0x25, 0xc9, 0xa6, 0xbc, 0x50, 0x1a, 0x0e, 0x3c, 0x96,
	0xed, 0x71, 0x73, 0x46, 0x9e, 0x81, 0x05, 0x0c, 0x6c, 0x8c, 0x29, 0x0e, 0x2c, 0x69, 0x22, 0xc3,
	0x6e, 0xc9, 0x0e, 0x20, 0x20, 0xe8, 0x14, 0xbb, 0x4b, 0x54, 0x43, 0xec, 0xc5, 0x55, 0x4d, 0x45,
	0x74, 0x2e, 0xf9, 0x09, 0x39, 0xe4, 0x94, 0x5f, 0x90, 0x5b, 0x7e, 0x41, 0xce, 0xc9, 0xd1, 0x47,
	0x9d, 0x84, 0x98, 0xbe, 0x04, 0xc9, 0xc5, 0x3f, 0x21, 0xa8, 0xa5, 0x17, 0x8a, 0x4d, 0xc9, 0x3e,
	0xb1, 0xea, 0xd5, 0xf7, 0xbe, 0x57, 0xf5, 0x96, 0xaa, 0xd7, 0x84, 0xfb, 0x8c, 0x5a, 0xb5, 0x63,
	0xe7, 0x8d, 0x43, 0x68, 0xcd, 0x25, 0x8c, 0xe1, 0x16, 0x61, 0xf1, 0x20, 0x68, 0xc6, 0x43, 0x3d,
	0xa0, 0x7e, 0xe8, 0x23, 0x14, 0x9c, 0xe8, 0x12, 0xad, 0x47, 0x2b, 0xd7, 0xee, 0xb7, 0x9c, 0xf0,
	0xb0, 0xd3, 0xd4, 0x2d, 0xdf, 0xad, 0xb5, 0xfc, 0x96, 0x5f, 0x13, 0xd0, 0x66, 0xe7, 0x40, 0xcc,
	0xc4, 0x44, 0x8c, 0x24, 0xc5, 0xb5, 0x65, 0x6e, 0x11, 0x07, 0x8e, 0x84, 0xd5, 0x3a, 0x1d, 0xc7,
	0x0e, 0x9a, 0xe2, 0x47, 0x01, 0x1e, 0x72, 0x80, 0x85, 0xa9, 0xe7, 0x87, 0xb5, 0xa0, 0x8d, 0x3d,
	0x8f, 0xd0, 0x9a, 0xed, 0xb0, 0x90, 0x3a, 0xcd, 0x4e, 0x48, 0x38, 0x38, 0x35, 0x33, 0x39, 0x42,
	0x29, 0x3e, 0xca, 0x52, 0xec, 0x7a, 0xd8, 0x75, 0x2c, 0x33, 0xa4, 0xd8, 0x72, 0xbc, 0x56, 0xcd,
	0xa1, 0xb5, 0xb6, 0xdf, 0x72, 0x2c, 0xdc, 0x0e, 0x9a, 0xd1, 0x48, 0xa9, 0xdf, 0x38, 0xa7, 0x1e,
	0x34, 0x6b, 0x29, 0xf2, 0x5b, 0x62, 0xd5, 0x77, 0x5d, 0xdf, 0xab, 0x35, 0x31, 0x23, 0x35, 0x16,
	0xe2, 0xb0, 0xc3, 0x5d, 0x24, 0x07, 0x0a, 0xb6, 0xca, 0x61, 0xec, 0x10, 0x53, 0x62, 0xd7, 0x8e,
	0xd6, 0xb9, 0x2b, 0x43, 0x6c, 0xe3, 0x10, 0x0b, 0x57, 0xca, 0xa1, 0x42, 0xfe, 0x23, 0xe5, 0x79,
	0x46, 0xe8, 0xb1, 0x63, 0x91, 0x04, 0x5e, 0x63, 0xa1, 0x4f, 0x89, 0x20, 0xf7, 0x29, 0x51, 0x1a,
	0x7a, 0x96, 0x86, 0xb2, 0x85, 0x5b, 0xc4, 0x0b, 0x83, 0xa6, 0xfc, 0x95, 0xf8, 0xea, 0x8f, 0xa3,
	0x30, 0xf5, 0x4a, 0xc0, 0x77, 0x64, 0xac, 0xd0, 0x97, 0x70, 0x85, 0x92, 0x96, 0xc3, 0x42, 0x42,
	0x4d, 0x81, 0x34, 0x29, 0x79, 0xdd, 0x21, 0x2c, 0x2c, 0x6b, 0x2b, 0xda, 0xea, 0xc4, 0xda, 0xaa,
	0x3e, 0x18, 0x5f, 0xdd, 0x50, 0x1a, 0x4f, 0xb8, 0x82, 0x21, 0xf1, 0x9b, 0x39, 0x63, 0x81, 0x66,
	0xc8, 0x91, 0x05, 0x57, 0x07, 0x2c, 0xb0, 0xc0, 0xf7, 0x18, 0x29, 0xe7, 0x85, 0x89, 0x3b, 0x1f,
	0x61, 0x42, 0x2a, 0x6c, 0xe6, 0x8c, 0x45, 0x9a, 0xb5, 0x80, 0x1e, 0xc1, 0xf8, 0x21, 0xc1, 0x34,
	0x6c, 0x12, 0x1c, 0x96, 0x47, 0x04, 0xed, 0xcd, 0x2c, 0xda, 0xcd, 0x08, 0xb4, 0x99, 0x33, 0x12,
	0x0d, 0xf4, 0x14, 0xa6, 0xe2, 0x89, 0x89, 0xad, 0xa3, 0xf2, 0xa8, 0xa0, 0x58, 0xb9, 0x90, 0xe2,
	0x89, 0x75, 0xb4, 0x99, 0x33, 0x26, 0x0f, 0x53, 0x73, 0xb4, 0x0d, 0xd3, 0x09, 0x91, 0xc7, 0x99,
	0xc6, 0x04, 0xd3, 0x5f, 0x2e, 0x64, 0x7a, 0x86, 0x05, 0x55, 0xb2, 0x07, 0x2e, 0x40, 0x5f, 0xc0,
	0x22, 0x39, 0x21, 0x56, 0x27, 0x24, 0xe6, 0xeb, 0x0e, 0xa1, 0xdd, 0x38, 0x32, 0x25, 0x41, 0x79,
	0x3b, 0x8b, 0xf2, 0x7f, 0x52, 0xe1, 0x05, 0xc7, 0x27, 0x81, 0x99, 0x27, 0x83, 0x62, 0xf4, 0x0a,
	0x10, 0x2f, 0x01, 0x12, 0xf8, 0x8e, 0x17, 0x9a, 0x8a, 0xa1, 0x0c, 0x82, 0xfb, 0x56, 0x16, 0xf7,
	0x5e, 0x8c, 0x56, 0xc9, 0xb3, 0x99, 0x33, 0xe6, 0xc2, 0xf3, 0x42, 0xbe, 0x6d, 0xcb, 0xf7, 0x0e,
	0x9c, 0x96, 0xd9, 0x09, 0x6c, 0x1c, 0x92, 0x98, 0x7a, 0x62, 0xf8, 0xb6, 0x37, 0x84, 0xc2, 0x4b,
	0x81, 0x4f, 0xc8, 0xe7, 0xad, 0x41, 0x31, 0xda, 0x87, 0x85, 0xa3, 0x75, 0x66, 0x46, 0x65, 0x11,
	0xb3, 0x4f, 0x0a, 0xf6, 0xbf, 0x65, 0xb1, 0xff, 0x7f, 0x9d, 0xed, 0x28, 0x78, 0x42, 0x8e, 0x8e,
	0x06, 0xa4, 0xf5, 0x11, 0x28, 0xb8, 0xac, 0xb5, 0x5d, 0x2c, 0x15, 0x66, 0x8b, 0xdb, 0xc5, 0x52,
	0x71, 0x76, 0xa4, 0x7a, 0x9a, 0x87, 0xb9, 0x81, 0x83, 0xf3, 0xaa, 0x49, 0xf9, 0xce, 0xf1, 0x0e,
	0x7c, 0x75, 0xd8, 0x8b, 0xaa, 0x26, 0xa1, 0xd9, 0xf2, 0x0e, 0x7c, 0x79, 0x2a, 0x5e, 0x35, 0x61,
	0x86, 0x1c, 0x39, 0xb0, 0x44, 0x89, 0xeb, 0x1f, 0x13, 0x33, 0x65, 0x28, 0x4a, 0x00, 0x59, 0x37,
	0xf7, 0xb2, 0xeb, 0x86, 0x2b, 0x25, 0xa6, 0x92, 0x24, 0xb8, 0x4a, 0xb3, 0x97, 0x90, 0x0f, 0xd7,
	0xe3, 0x02, 0xcd, 0x30, 0x56, 0x10, 0xc6, 0xee, 0x5f, 0x54, 0xa4, 0x59, 0xe6, 0x96, 0xe8, 0xb0,
	0x45, 0xe5, 0xe6, 0xea, 0xd7, 0x30, 0x9f, 0x11, 0xf7, 0xc1, 0xfc, 0xe9, 0xbf, 0x90, 0x2e, 0xcd,
	0x9f, 0x54, 0xda, 0x5b, 0x83, 0xe2, 0xc8, 0xf8, 0xef, 0x79, 0x40, 0x83, 0x79, 0x81, 0xf6, 0x61,
	0xbe, 0x2f, 0xbb, 0x06, 0xa3, 0x2a, 0x6f, 0x57, 0xfd, 0x68, 0x9d, 0xe9, 0xc9, 0x4d, 0xae, 0x1b,
	0x84, 0xf9, 0x1d, 0x6a, 0x91, 0x38, 0xaa, 0x73, 0xa9, 0xf4, 0x52, 0x21, 0x3d, 0x86, 0x1b, 0xae,
	0xc3, 0x98, 0xe3, 0xb5, 0xcc, 0x3e, 0x1b, 0xfd, 0x51, 0x7d, 0x30, 0xdc, 0xc8, 0x8e, 0xd4, 0x4e,
	0x6d, 0x3b, 0xe5, 0x6e, 0x77, 0xd8, 0x22, 0xea, 0xc2, 0xcd, 0x21, 0x76, 0xd5, 0x35, 0x2c, 0x23,
	0xfc, 0xaf, 0x4f, 0x33, 0x1c, 0xdf, 0xc8, 0xd7, 0xdc, 0xa1, 0xab, 0x91, 0xb3, 0xdf, 0xc0, 0x42,
	0xd6, 0x93, 0x81, 0x1e, 0x43, 0x91, 0xd7, 0x8e, 0x72, 0xef, 0xdd, 0x54, 0x64, 0xa3, 0xc7, 0x2c,
	0xda, 0x90, 0x7c, 0xc4, 0x84, 0x32, 0x2f, 0x12, 0x43, 0xe8, 0xa1, 0x1b, 0x50, 0xc4, 0xcc, 0xb1,
	0xc5, 0x01, 0xa6, 0xea, 0xa5, 0xde, 0xd9, 0x72, 0xf1, 0xc9, 0xee, 0x56, 0xc3, 0x10, 0xd2, 0xed,
	0x62, 0x29, 0x3f, 0x5b, 0xa8, 0xfe, 0x07, 0x16, 0x33, 0xdf, 0x92, 0x58, 0x59, 0xbb, 0x40, 0xd9,
	0x82, 0x29, 0xa1, 0xd4, 0xc0, 0x21, 0xe6, 0x76, 0x91, 0x01, 0x53, 0xb1, 0xff, 0x52, 0x5b, 0x17,
	0xd5, 0x21, 0x1b, 0x05, 0x5d, 0xf5, 0x19, 0x7a, 0x5f, 0x83, 0xa2, 0x47, 0xae, 0x11, 0xbb, 0x9f,
	0x74, 0x53, 0xb3, 0xea, 0x1f, 0x79, 0x98, 0x11, 0x56, 0x64, 0x9e, 0x08, 0x3b, 0x8f, 0x61, 0x94,
	0x59, 0x87, 0xc4, 0xc5, 0xe5, 0xfc, 0x4a, 0xe1, 0xdc, 0xbd, 0x16, 0xfb, 0x26, 0x6e, 0x1f, 0xf6,
	0x70, 0xb3, 0x2d, 0xf4, 0x0c, 0xa5, 0x85, 0x5e, 0xc0, 0x4c, 0x40, 0x7d, 0x8b, 0x30, 0x66, 0x5a,
	0x94, 0xe0, 0x90, 0xd8, 0xe5, 0xa2, 0x20, 0xba, 0x20, 0x87, 0x9f, 0x4b, 0x85, 0x0d, 0x89, 0x37,
	0xa6, 0x83, 0xbe, 0x39, 0xda, 0x07, 0x14, 0x51, 0x86, 0x84, 0xba, 0x8e, 0x27, 0x58, 0x47, 0x04,
	0xeb, 0xbd, 0x4b, 0x59, 0xf7, 0x62, 0x15, 0x63, 0x2e, 0x38, 0x2f, 0x42, 0x7f, 0x07, 0x64, 0xfb,
	0x84, 0x45, 0x15, 0xaf, 0x8e, 0xce, 0x1f, 0xe1, 0x92, 0x31, 0xcb, 0x57, 0xa4, 0x6b, 0x76, 0xe5,
	0xe1, 0xfe, 0x0d, 0x45, 0x4e, 0x7e, 0xd1, 0xd3, 0xda, 0x17, 0x35, 0x43, 0xc0, 0xe5, 0xb5, 0x5e,
	0xfd, 0x59, 0x83, 0xf1, 0xf8, 0xe1, 0x45, 0x0f, 0xa1, 0x24, 0x7b, 0x12, 0x95, 0x08, 0x13, 0x6b,
	0x33, 0x9c, 0x4e, 0xb6, 0xa0, 0xfa, 0xcb, 0x97, 0x5b, 0x8d, 0xfa, 0x44, 0xef, 0x6c, 0x79, 0x4c,
	0x66, 0x5e, 0xc3, 0x18, 0x13, 0xe8, 0x2d, 0x1b, 0x21, 0x28, 0x86, 0x8e, 0x2b, 0x5b, 0x98, 0x82,
	0x21, 0xc6, 0xa8, 0x01, 0x13, 0xea, 0x00, 0x22, 0x35, 0x64, 0x59, 0xfd, 0x75, 0xe8, 0xf6, 0x92,
	0x70, 0x1b, 0xd0, 0x49, 0x42, 0x7f, 0x1b, 0x66, 0x18, 0xaf, 0x0f, 0xcf, 0x22, 0xa6, 0xd7, 0x71,
	0x9b, 0x84, 0x96, 0x8b, 0xc2, 0xc8, 0x74, 0x24, 0x7e, 0x26, 0xa4, 0xd5, 0x2e, 0xa0, 0xfe, 0x1b,
	0x46, 0xa8, 0xaf, 0xc1, 0xa4, 0x4a, 0x10, 0xd3, 0x72, 0x6c, 0x2a, 0x36, 0x38, 0x5e, 0x9f, 0xe9,
	0x9d, 0x2d, 0x4f, 0xec, 0x4a, 0xf9, 0xc6, 0x56, 0xc3, 0x30, 0x26, 0x14, 0x68, 0xc3, 0xb1, 0x29,
	0xba, 0x03, 0xe3, 0x81, 0x6f, 0x0b, 0x3c, 0x2b, 0x17, 0x56, 0x0a, 0xab, 0xe3, 0xf5, 0xc9, 0xde,
	0xd9, 0x72, 0xe9, 0xb9, 0x6f, 0x73, 0x30, 0x33, 0x4a, 0x81, 0x6f, 0x73, 0x24, 0xdb, 0x2e, 0x96,
	0xb4, 0xd9, 0x7c, 0xf5, 0x3b, 0x0d, 0x26, 0xd3, 0x7d, 0x50, 0xec, 0x0e, 0x2d, 0xe5, 0x8e, 0x8c,
	0x83, 0xe4, 0xb3, 0x0e, 0x82, 0x9e, 0x66, 0xf9, 0x2d, 0xf3, 0x25, 0x1f, 0x3c, 0x6f, 0xda, 0x75,
	0xd5, 0x1a, 0x4c, 0xf5, 0xf5, 0x54, 0xa8, 0x02, 0x40, 0x49, 0xf4, 0x10, 0x89, 0xcd, 0x95, 0x8c,
	0x94, 0xa4, 0xfa, 0xbd, 0x06, 0xf3, 0x19, 0x2d, 0x13, 0x4f, 0x0b, 0xd9, 0x72, 0x5d, 0x92, 0x16,
	0x42, 0x89, 0xa7, 0x85, 0x40, 0x6f, 0xd9, 0xe8, 0x2e, 0x14, 0x79, 0xfd, 0xab, 0x33, 0x5c, 0x39,
	0x77, 0x2d, 0xf0, 0x72, 0x68, 0x63, 0xcf, 0x10, 0x18, 0x54, 0x86, 0x31, 0xec, 0xe1, 0x76, 0xf7,
	0x0d, 0x11, 0x01, 0x2e, 0x19, 0xd1, 0x54, 0x5d, 0x3e, 0x3f, 0x69, 0xb0, 0x34, 0xf4, 0x85, 0x45,
	0x5f, 0xc1, 0x62, 0xea, 0xb1, 0xb6, 0x49, 0xd0, 0xf6, 0xbb, 0x2e, 0xf1, 0xa2, 0x67, 0xb2, 0x9e,
	0x75, 0x23, 0xf5, 0x7f, 0xf9, 0xe8, 0x0e, 0xd5, 0xa3, 0xef, 0x9d, 0x84, 0xbf, 0x11, 0x33, 0xa5,
	0x3b, 0x93, 0x44, 0x8a, 0x6e, 0x43, 0xde, 0xb1, 0xd5, 0x63, 0x35, 0xe0, 0x95, 0xd1, 0xde, 0xd9,
	0x72, 0x7e, 0xab, 0x61, 0xe4, 0x1d, 0xbb, 0x7a, 0xaa, 0xc1, 0x42, 0x56, 0xcf, 0xa3, 0x18, 0xb4,
	0x4b, 0x19, 0xd0, 0x3f, 0x61, 0x84, 0x7f, 0x4a, 0xc9, 0x2a, 0x9b, 0x5e, 0xbb, 0x2e, 0x6e, 0x19,
	0xf5, 0x91, 0xa5, 0x7f, 0xe6, 0x1c, 0x90, 0x8d, 0xae, 0xd5, 0x26, 0xbb, 0x1c, 0x62, 0x48, 0x24,
	0xba, 0x07, 0xa3, 0x12, 0xa1, 0x42, 0x30, 0xdf, 0xa7, 0xb3, 0x2b, 0x06, 0x86, 0x82, 0xf4, 0x55,
	0x7f, 0xf1, 0x13, 0xaa, 0xbf, 0x5a, 0x87, 0xab, 0x43, 0x1a, 0xad, 0x8f, 0x3e, 0x5c, 0xf5, 0x51,
	0x7f, 0xfb, 0x13, 0xe9, 0xcf, 0x42, 0xe1, 0x88, 0x74, 0x05, 0xc1, 0xb8, 0xc1, 0x87, 0x68, 0x01,
	0x46, 0x8e, 0x71, 0xbb, 0x23, 0xbd, 0x30, 0x6e, 0xc8, 0x49, 0xf5, 0x73, 0x98, 0xde, 0x21, 0x21,
	0x75, 0x2c, 0x16, 0xf5, 0x2e, 0x77, 0x81, 0xdf, 0xac, 0x2e, 0x7f, 0xe0, 0xb9, 0xd8, 0x0c, 0xc9,
	0x49, 0xa8, 0x78, 0xf8, 0x63, 0xe0, 0x2a, 0xf8, 0x1e, 0x39, 0x09, 0xd1, 0x12, 0xf0, 0x92, 0x36,
	0x3d, 0xec, 0x46, 0xb4, 0x63, 0x81, 0x6f, 0x3f, 0xc3, 0x2e, 0xa9, 0xff, 0xf7, 0xed, 0xbb, 0x4a,
	0xee, 0xf4, 0x5d, 0x25, 0xf7, 0xe1, 0x5d, 0x45, 0xfb, 0xa6, 0x57, 0xd1, 0x7e, 0xe8, 0x55, 0xb4,
	0x5f, 0x7a, 0x15, 0xed, 0x6d, 0xaf, 0xa2, 0xfd, 0xda, 0xab, 0x68, 0xbf, 0xf5, 0x2a, 0xb9, 0x0f,
	0xbd, 0x8a, 0xf6, 0xed, 0xfb, 0x4a, 0xee, 0xed, 0xfb, 0x4a, 0xee, 0xf4, 0x7d, 0x25, 0xb7, 0x0f,
	0xc9, 0x3f, 0x04, 0xcd, 0x51, 0xf1, 0xb1, 0xf9, 0xe0, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x82,
	0xe8, 0x3e, 0x85, 0x4a, 0x10, 0x00, 0x00,
}

func (this *VizierMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VizierMessage)
	if !ok {
		that2, ok := that.(VizierMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Msg == nil {
		if this.Msg != nil {
			return false
		}
	} else if this.Msg == nil {
		return false
	} else if !this.Msg.Equal(that1.Msg) {
		return false
	}
	return true
}
func (this *VizierMessage_RegisterAgentRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VizierMessage_RegisterAgentRequest)
	if !ok {
		that2, ok := that.(VizierMessage_RegisterAgentRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RegisterAgentRequest.Equal(that1.RegisterAgentRequest) {
		return false
	}
	return true
}
func (this *VizierMessage_RegisterAgentResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VizierMessage_RegisterAgentResponse)
	if !ok {
		that2, ok := that.(VizierMessage_RegisterAgentResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RegisterAgentResponse.Equal(that1.RegisterAgentResponse) {
		return false
	}
	return true
}
func (this *VizierMessage_Heartbeat) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VizierMessage_Heartbeat)
	if !ok {
		that2, ok := that.(VizierMessage_Heartbeat)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Heartbeat.Equal(that1.Heartbeat) {
		return false
	}
	return true
}
func (this *VizierMessage_HeartbeatAck) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VizierMessage_HeartbeatAck)
	if !ok {
		that2, ok := that.(VizierMessage_HeartbeatAck)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.HeartbeatAck.Equal(that1.HeartbeatAck) {
		return false
	}
	return true
}
func (this *VizierMessage_HeartbeatNack) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VizierMessage_HeartbeatNack)
	if !ok {
		that2, ok := that.(VizierMessage_HeartbeatNack)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.HeartbeatNack.Equal(that1.HeartbeatNack) {
		return false
	}
	return true
}
func (this *VizierMessage_ExecuteQueryRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VizierMessage_ExecuteQueryRequest)
	if !ok {
		that2, ok := that.(VizierMessage_ExecuteQueryRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ExecuteQueryRequest.Equal(that1.ExecuteQueryRequest) {
		return false
	}
	return true
}
func (this *VizierMessage_TracepointMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VizierMessage_TracepointMessage)
	if !ok {
		that2, ok := that.(VizierMessage_TracepointMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.TracepointMessage.Equal(that1.TracepointMessage) {
		return false
	}
	return true
}
func (this *VizierMessage_ConfigUpdateMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VizierMessage_ConfigUpdateMessage)
	if !ok {
		that2, ok := that.(VizierMessage_ConfigUpdateMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ConfigUpdateMessage.Equal(that1.ConfigUpdateMessage) {
		return false
	}
	return true
}
func (this *VizierMessage_K8SMetadataMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VizierMessage_K8SMetadataMessage)
	if !ok {
		that2, ok := that.(VizierMessage_K8SMetadataMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.K8SMetadataMessage.Equal(that1.K8SMetadataMessage) {
		return false
	}
	return true
}
func (this *TracepointMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointMessage)
	if !ok {
		that2, ok := that.(TracepointMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Msg == nil {
		if this.Msg != nil {
			return false
		}
	} else if this.Msg == nil {
		return false
	} else if !this.Msg.Equal(that1.Msg) {
		return false
	}
	return true
}
func (this *TracepointMessage_TracepointInfoUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointMessage_TracepointInfoUpdate)
	if !ok {
		that2, ok := that.(TracepointMessage_TracepointInfoUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.TracepointInfoUpdate.Equal(that1.TracepointInfoUpdate) {
		return false
	}
	return true
}
func (this *TracepointMessage_RemoveTracepointRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointMessage_RemoveTracepointRequest)
	if !ok {
		that2, ok := that.(TracepointMessage_RemoveTracepointRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RemoveTracepointRequest.Equal(that1.RemoveTracepointRequest) {
		return false
	}
	return true
}
func (this *TracepointMessage_RegisterTracepointRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointMessage_RegisterTracepointRequest)
	if !ok {
		that2, ok := that.(TracepointMessage_RegisterTracepointRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RegisterTracepointRequest.Equal(that1.RegisterTracepointRequest) {
		return false
	}
	return true
}
func (this *ConfigUpdateMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ConfigUpdateMessage)
	if !ok {
		that2, ok := that.(ConfigUpdateMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Msg == nil {
		if this.Msg != nil {
			return false
		}
	} else if this.Msg == nil {
		return false
	} else if !this.Msg.Equal(that1.Msg) {
		return false
	}
	return true
}
func (this *ConfigUpdateMessage_ConfigUpdateRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ConfigUpdateMessage_ConfigUpdateRequest)
	if !ok {
		that2, ok := that.(ConfigUpdateMessage_ConfigUpdateRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ConfigUpdateRequest.Equal(that1.ConfigUpdateRequest) {
		return false
	}
	return true
}
func (this *K8SMetadataMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*K8SMetadataMessage)
	if !ok {
		that2, ok := that.(K8SMetadataMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Msg == nil {
		if this.Msg != nil {
			return false
		}
	} else if this.Msg == nil {
		return false
	} else if !this.Msg.Equal(that1.Msg) {
		return false
	}
	return true
}
func (this *K8SMetadataMessage_K8SMetadataUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*K8SMetadataMessage_K8SMetadataUpdate)
	if !ok {
		that2, ok := that.(K8SMetadataMessage_K8SMetadataUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.K8SMetadataUpdate.Equal(that1.K8SMetadataUpdate) {
		return false
	}
	return true
}
func (this *K8SMetadataMessage_MissingK8SMetadataRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*K8SMetadataMessage_MissingK8SMetadataRequest)
	if !ok {
		that2, ok := that.(K8SMetadataMessage_MissingK8SMetadataRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.MissingK8SMetadataRequest.Equal(that1.MissingK8SMetadataRequest) {
		return false
	}
	return true
}
func (this *K8SMetadataMessage_MissingK8SMetadataResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*K8SMetadataMessage_MissingK8SMetadataResponse)
	if !ok {
		that2, ok := that.(K8SMetadataMessage_MissingK8SMetadataResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.MissingK8SMetadataResponse.Equal(that1.MissingK8SMetadataResponse) {
		return false
	}
	return true
}
func (this *RegisterAgentRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RegisterAgentRequest)
	if !ok {
		that2, ok := that.(RegisterAgentRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Info.Equal(that1.Info) {
		return false
	}
	if this.ASID != that1.ASID {
		return false
	}
	return true
}
func (this *RegisterAgentResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RegisterAgentResponse)
	if !ok {
		that2, ok := that.(RegisterAgentResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ASID != that1.ASID {
		return false
	}
	return true
}
func (this *AgentDataInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AgentDataInfo)
	if !ok {
		that2, ok := that.(AgentDataInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.MetadataInfo.Equal(that1.MetadataInfo) {
		return false
	}
	return true
}
func (this *AgentUpdateInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AgentUpdateInfo)
	if !ok {
		that2, ok := that.(AgentUpdateInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Schema) != len(that1.Schema) {
		return false
	}
	for i := range this.Schema {
		if !this.Schema[i].Equal(that1.Schema[i]) {
			return false
		}
	}
	if len(this.ProcessCreated) != len(that1.ProcessCreated) {
		return false
	}
	for i := range this.ProcessCreated {
		if !this.ProcessCreated[i].Equal(that1.ProcessCreated[i]) {
			return false
		}
	}
	if len(this.ProcessTerminated) != len(that1.ProcessTerminated) {
		return false
	}
	for i := range this.ProcessTerminated {
		if !this.ProcessTerminated[i].Equal(that1.ProcessTerminated[i]) {
			return false
		}
	}
	if this.DoesUpdateSchema != that1.DoesUpdateSchema {
		return false
	}
	if !this.Data.Equal(that1.Data) {
		return false
	}
	return true
}
func (this *Heartbeat) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Heartbeat)
	if !ok {
		that2, ok := that.(Heartbeat)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.AgentID.Equal(that1.AgentID) {
		return false
	}
	if this.Time != that1.Time {
		return false
	}
	if !this.UpdateInfo.Equal(that1.UpdateInfo) {
		return false
	}
	if this.SequenceNumber != that1.SequenceNumber {
		return false
	}
	return true
}
func (this *MetadataUpdateInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetadataUpdateInfo)
	if !ok {
		that2, ok := that.(MetadataUpdateInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ServiceCIDR != that1.ServiceCIDR {
		return false
	}
	if len(this.PodCIDRs) != len(that1.PodCIDRs) {
		return false
	}
	for i := range this.PodCIDRs {
		if this.PodCIDRs[i] != that1.PodCIDRs[i] {
			return false
		}
	}
	return true
}
func (this *HeartbeatAck) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HeartbeatAck)
	if !ok {
		that2, ok := that.(HeartbeatAck)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Time != that1.Time {
		return false
	}
	if this.SequenceNumber != that1.SequenceNumber {
		return false
	}
	if !this.UpdateInfo.Equal(that1.UpdateInfo) {
		return false
	}
	return true
}
func (this *HeartbeatNack) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HeartbeatNack)
	if !ok {
		that2, ok := that.(HeartbeatNack)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Reregister != that1.Reregister {
		return false
	}
	return true
}
func (this *ExecuteQueryRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExecuteQueryRequest)
	if !ok {
		that2, ok := that.(ExecuteQueryRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.QueryID.Equal(that1.QueryID) {
		return false
	}
	if !this.Plan.Equal(that1.Plan) {
		return false
	}
	if this.Analyze != that1.Analyze {
		return false
	}
	return true
}
func (this *RegisterTracepointRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RegisterTracepointRequest)
	if !ok {
		that2, ok := that.(RegisterTracepointRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.TracepointDeployment.Equal(that1.TracepointDeployment) {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	return true
}
func (this *TracepointInfoUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointInfoUpdate)
	if !ok {
		that2, ok := that.(TracepointInfoUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	if this.State != that1.State {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	if !this.AgentID.Equal(that1.AgentID) {
		return false
	}
	return true
}
func (this *RemoveTracepointRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RemoveTracepointRequest)
	if !ok {
		that2, ok := that.(RemoveTracepointRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	return true
}
func (this *ConfigUpdateRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ConfigUpdateRequest)
	if !ok {
		that2, ok := that.(ConfigUpdateRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	return true
}
func (this *MetricsMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetricsMessage)
	if !ok {
		that2, ok := that.(MetricsMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.PromMetricsText != that1.PromMetricsText {
		return false
	}
	if this.PodName != that1.PodName {
		return false
	}
	return true
}
func (this *VizierMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 13)
	s = append(s, "&messagespb.VizierMessage{")
	if this.Msg != nil {
		s = append(s, "Msg: "+fmt.Sprintf("%#v", this.Msg)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *VizierMessage_RegisterAgentRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.VizierMessage_RegisterAgentRequest{` +
		`RegisterAgentRequest:` + fmt.Sprintf("%#v", this.RegisterAgentRequest) + `}`}, ", ")
	return s
}
func (this *VizierMessage_RegisterAgentResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.VizierMessage_RegisterAgentResponse{` +
		`RegisterAgentResponse:` + fmt.Sprintf("%#v", this.RegisterAgentResponse) + `}`}, ", ")
	return s
}
func (this *VizierMessage_Heartbeat) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.VizierMessage_Heartbeat{` +
		`Heartbeat:` + fmt.Sprintf("%#v", this.Heartbeat) + `}`}, ", ")
	return s
}
func (this *VizierMessage_HeartbeatAck) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.VizierMessage_HeartbeatAck{` +
		`HeartbeatAck:` + fmt.Sprintf("%#v", this.HeartbeatAck) + `}`}, ", ")
	return s
}
func (this *VizierMessage_HeartbeatNack) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.VizierMessage_HeartbeatNack{` +
		`HeartbeatNack:` + fmt.Sprintf("%#v", this.HeartbeatNack) + `}`}, ", ")
	return s
}
func (this *VizierMessage_ExecuteQueryRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.VizierMessage_ExecuteQueryRequest{` +
		`ExecuteQueryRequest:` + fmt.Sprintf("%#v", this.ExecuteQueryRequest) + `}`}, ", ")
	return s
}
func (this *VizierMessage_TracepointMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.VizierMessage_TracepointMessage{` +
		`TracepointMessage:` + fmt.Sprintf("%#v", this.TracepointMessage) + `}`}, ", ")
	return s
}
func (this *VizierMessage_ConfigUpdateMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.VizierMessage_ConfigUpdateMessage{` +
		`ConfigUpdateMessage:` + fmt.Sprintf("%#v", this.ConfigUpdateMessage) + `}`}, ", ")
	return s
}
func (this *VizierMessage_K8SMetadataMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.VizierMessage_K8SMetadataMessage{` +
		`K8SMetadataMessage:` + fmt.Sprintf("%#v", this.K8SMetadataMessage) + `}`}, ", ")
	return s
}
func (this *TracepointMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&messagespb.TracepointMessage{")
	if this.Msg != nil {
		s = append(s, "Msg: "+fmt.Sprintf("%#v", this.Msg)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TracepointMessage_TracepointInfoUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.TracepointMessage_TracepointInfoUpdate{` +
		`TracepointInfoUpdate:` + fmt.Sprintf("%#v", this.TracepointInfoUpdate) + `}`}, ", ")
	return s
}
func (this *TracepointMessage_RemoveTracepointRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.TracepointMessage_RemoveTracepointRequest{` +
		`RemoveTracepointRequest:` + fmt.Sprintf("%#v", this.RemoveTracepointRequest) + `}`}, ", ")
	return s
}
func (this *TracepointMessage_RegisterTracepointRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.TracepointMessage_RegisterTracepointRequest{` +
		`RegisterTracepointRequest:` + fmt.Sprintf("%#v", this.RegisterTracepointRequest) + `}`}, ", ")
	return s
}
func (this *ConfigUpdateMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&messagespb.ConfigUpdateMessage{")
	if this.Msg != nil {
		s = append(s, "Msg: "+fmt.Sprintf("%#v", this.Msg)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ConfigUpdateMessage_ConfigUpdateRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.ConfigUpdateMessage_ConfigUpdateRequest{` +
		`ConfigUpdateRequest:` + fmt.Sprintf("%#v", this.ConfigUpdateRequest) + `}`}, ", ")
	return s
}
func (this *K8SMetadataMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&messagespb.K8SMetadataMessage{")
	if this.Msg != nil {
		s = append(s, "Msg: "+fmt.Sprintf("%#v", this.Msg)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *K8SMetadataMessage_K8SMetadataUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.K8SMetadataMessage_K8SMetadataUpdate{` +
		`K8SMetadataUpdate:` + fmt.Sprintf("%#v", this.K8SMetadataUpdate) + `}`}, ", ")
	return s
}
func (this *K8SMetadataMessage_MissingK8SMetadataRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.K8SMetadataMessage_MissingK8SMetadataRequest{` +
		`MissingK8SMetadataRequest:` + fmt.Sprintf("%#v", this.MissingK8SMetadataRequest) + `}`}, ", ")
	return s
}
func (this *K8SMetadataMessage_MissingK8SMetadataResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&messagespb.K8SMetadataMessage_MissingK8SMetadataResponse{` +
		`MissingK8SMetadataResponse:` + fmt.Sprintf("%#v", this.MissingK8SMetadataResponse) + `}`}, ", ")
	return s
}
func (this *RegisterAgentRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&messagespb.RegisterAgentRequest{")
	if this.Info != nil {
		s = append(s, "Info: "+fmt.Sprintf("%#v", this.Info)+",\n")
	}
	s = append(s, "ASID: "+fmt.Sprintf("%#v", this.ASID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RegisterAgentResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&messagespb.RegisterAgentResponse{")
	s = append(s, "ASID: "+fmt.Sprintf("%#v", this.ASID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AgentDataInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&messagespb.AgentDataInfo{")
	if this.MetadataInfo != nil {
		s = append(s, "MetadataInfo: "+fmt.Sprintf("%#v", this.MetadataInfo)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AgentUpdateInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&messagespb.AgentUpdateInfo{")
	if this.Schema != nil {
		s = append(s, "Schema: "+fmt.Sprintf("%#v", this.Schema)+",\n")
	}
	if this.ProcessCreated != nil {
		s = append(s, "ProcessCreated: "+fmt.Sprintf("%#v", this.ProcessCreated)+",\n")
	}
	if this.ProcessTerminated != nil {
		s = append(s, "ProcessTerminated: "+fmt.Sprintf("%#v", this.ProcessTerminated)+",\n")
	}
	s = append(s, "DoesUpdateSchema: "+fmt.Sprintf("%#v", this.DoesUpdateSchema)+",\n")
	if this.Data != nil {
		s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Heartbeat) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&messagespb.Heartbeat{")
	if this.AgentID != nil {
		s = append(s, "AgentID: "+fmt.Sprintf("%#v", this.AgentID)+",\n")
	}
	s = append(s, "Time: "+fmt.Sprintf("%#v", this.Time)+",\n")
	if this.UpdateInfo != nil {
		s = append(s, "UpdateInfo: "+fmt.Sprintf("%#v", this.UpdateInfo)+",\n")
	}
	s = append(s, "SequenceNumber: "+fmt.Sprintf("%#v", this.SequenceNumber)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MetadataUpdateInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&messagespb.MetadataUpdateInfo{")
	s = append(s, "ServiceCIDR: "+fmt.Sprintf("%#v", this.ServiceCIDR)+",\n")
	s = append(s, "PodCIDRs: "+fmt.Sprintf("%#v", this.PodCIDRs)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *HeartbeatAck) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&messagespb.HeartbeatAck{")
	s = append(s, "Time: "+fmt.Sprintf("%#v", this.Time)+",\n")
	s = append(s, "SequenceNumber: "+fmt.Sprintf("%#v", this.SequenceNumber)+",\n")
	if this.UpdateInfo != nil {
		s = append(s, "UpdateInfo: "+fmt.Sprintf("%#v", this.UpdateInfo)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *HeartbeatNack) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&messagespb.HeartbeatNack{")
	s = append(s, "Reregister: "+fmt.Sprintf("%#v", this.Reregister)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExecuteQueryRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&messagespb.ExecuteQueryRequest{")
	if this.QueryID != nil {
		s = append(s, "QueryID: "+fmt.Sprintf("%#v", this.QueryID)+",\n")
	}
	if this.Plan != nil {
		s = append(s, "Plan: "+fmt.Sprintf("%#v", this.Plan)+",\n")
	}
	s = append(s, "Analyze: "+fmt.Sprintf("%#v", this.Analyze)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RegisterTracepointRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&messagespb.RegisterTracepointRequest{")
	if this.TracepointDeployment != nil {
		s = append(s, "TracepointDeployment: "+fmt.Sprintf("%#v", this.TracepointDeployment)+",\n")
	}
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TracepointInfoUpdate) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&messagespb.TracepointInfoUpdate{")
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	s = append(s, "State: "+fmt.Sprintf("%#v", this.State)+",\n")
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	if this.AgentID != nil {
		s = append(s, "AgentID: "+fmt.Sprintf("%#v", this.AgentID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RemoveTracepointRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&messagespb.RemoveTracepointRequest{")
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ConfigUpdateRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&messagespb.ConfigUpdateRequest{")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MetricsMessage) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&messagespb.MetricsMessage{")
	s = append(s, "PromMetricsText: "+fmt.Sprintf("%#v", this.PromMetricsText)+",\n")
	s = append(s, "PodName: "+fmt.Sprintf("%#v", this.PodName)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringMessages(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *VizierMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *VizierMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VizierMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Msg != nil {
		{
			size := m.Msg.Size()
			i -= size
			if _, err := m.Msg.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *VizierMessage_RegisterAgentRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VizierMessage_RegisterAgentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RegisterAgentRequest != nil {
		{
			size, err := m.RegisterAgentRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *VizierMessage_RegisterAgentResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VizierMessage_RegisterAgentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RegisterAgentResponse != nil {
		{
			size, err := m.RegisterAgentResponse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *VizierMessage_Heartbeat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VizierMessage_Heartbeat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Heartbeat != nil {
		{
			size, err := m.Heartbeat.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *VizierMessage_HeartbeatAck) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VizierMessage_HeartbeatAck) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.HeartbeatAck != nil {
		{
			size, err := m.HeartbeatAck.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *VizierMessage_HeartbeatNack) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VizierMessage_HeartbeatNack) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.HeartbeatNack != nil {
		{
			size, err := m.HeartbeatNack.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *VizierMessage_ExecuteQueryRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VizierMessage_ExecuteQueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ExecuteQueryRequest != nil {
		{
			size, err := m.ExecuteQueryRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *VizierMessage_TracepointMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VizierMessage_TracepointMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.TracepointMessage != nil {
		{
			size, err := m.TracepointMessage.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *VizierMessage_ConfigUpdateMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VizierMessage_ConfigUpdateMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ConfigUpdateMessage != nil {
		{
			size, err := m.ConfigUpdateMessage.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	return len(dAtA) - i, nil
}
func (m *VizierMessage_K8SMetadataMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VizierMessage_K8SMetadataMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.K8SMetadataMessage != nil {
		{
			size, err := m.K8SMetadataMessage.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	return len(dAtA) - i, nil
}
func (m *TracepointMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TracepointMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Msg != nil {
		{
			size := m.Msg.Size()
			i -= size
			if _, err := m.Msg.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *TracepointMessage_TracepointInfoUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointMessage_TracepointInfoUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.TracepointInfoUpdate != nil {
		{
			size, err := m.TracepointInfoUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *TracepointMessage_RemoveTracepointRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointMessage_RemoveTracepointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RemoveTracepointRequest != nil {
		{
			size, err := m.RemoveTracepointRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *TracepointMessage_RegisterTracepointRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointMessage_RegisterTracepointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RegisterTracepointRequest != nil {
		{
			size, err := m.RegisterTracepointRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *ConfigUpdateMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConfigUpdateMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConfigUpdateMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Msg != nil {
		{
			size := m.Msg.Size()
			i -= size
			if _, err := m.Msg.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *ConfigUpdateMessage_ConfigUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConfigUpdateMessage_ConfigUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ConfigUpdateRequest != nil {
		{
			size, err := m.ConfigUpdateRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *K8SMetadataMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *K8SMetadataMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *K8SMetadataMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Msg != nil {
		{
			size := m.Msg.Size()
			i -= size
			if _, err := m.Msg.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *K8SMetadataMessage_K8SMetadataUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *K8SMetadataMessage_K8SMetadataUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.K8SMetadataUpdate != nil {
		{
			size, err := m.K8SMetadataUpdate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *K8SMetadataMessage_MissingK8SMetadataRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *K8SMetadataMessage_MissingK8SMetadataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MissingK8SMetadataRequest != nil {
		{
			size, err := m.MissingK8SMetadataRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *K8SMetadataMessage_MissingK8SMetadataResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *K8SMetadataMessage_MissingK8SMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MissingK8SMetadataResponse != nil {
		{
			size, err := m.MissingK8SMetadataResponse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *RegisterAgentRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RegisterAgentRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterAgentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ASID != 0 {
		i = encodeVarintMessages(dAtA, i, uint64(m.ASID))
		i--
		dAtA[i] = 0x18
	}
	if m.Info != nil {
		{
			size, err := m.Info.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RegisterAgentResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RegisterAgentResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterAgentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ASID != 0 {
		i = encodeVarintMessages(dAtA, i, uint64(m.ASID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AgentDataInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AgentDataInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentDataInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MetadataInfo != nil {
		{
			size, err := m.MetadataInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AgentUpdateInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AgentUpdateInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentUpdateInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.DoesUpdateSchema {
		i--
		if m.DoesUpdateSchema {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if len(m.ProcessTerminated) > 0 {
		for iNdEx := len(m.ProcessTerminated) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ProcessTerminated[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMessages(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.ProcessCreated) > 0 {
		for iNdEx := len(m.ProcessCreated) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ProcessCreated[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMessages(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Schema) > 0 {
		for iNdEx := len(m.Schema) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Schema[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMessages(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	return len(dAtA) - i, nil
}

func (m *Heartbeat) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Heartbeat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Heartbeat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SequenceNumber != 0 {
		i = encodeVarintMessages(dAtA, i, uint64(m.SequenceNumber))
		i--
		dAtA[i] = 0x20
	}
	if m.UpdateInfo != nil {
		{
			size, err := m.UpdateInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Time != 0 {
		i = encodeVarintMessages(dAtA, i, uint64(m.Time))
		i--
		dAtA[i] = 0x10
	}
	if m.AgentID != nil {
		{
			size, err := m.AgentID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MetadataUpdateInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MetadataUpdateInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataUpdateInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PodCIDRs) > 0 {
		for iNdEx := len(m.PodCIDRs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PodCIDRs[iNdEx])
			copy(dAtA[i:], m.PodCIDRs[iNdEx])
			i = encodeVarintMessages(dAtA, i, uint64(len(m.PodCIDRs[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.ServiceCIDR) > 0 {
		i -= len(m.ServiceCIDR)
		copy(dAtA[i:], m.ServiceCIDR)
		i = encodeVarintMessages(dAtA, i, uint64(len(m.ServiceCIDR)))
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *HeartbeatAck) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HeartbeatAck) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HeartbeatAck) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpdateInfo != nil {
		{
			size, err := m.UpdateInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.SequenceNumber != 0 {
		i = encodeVarintMessages(dAtA, i, uint64(m.SequenceNumber))
		i--
		dAtA[i] = 0x10
	}
	if m.Time != 0 {
		i = encodeVarintMessages(dAtA, i, uint64(m.Time))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *HeartbeatNack) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HeartbeatNack) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HeartbeatNack) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Reregister {
		i--
		if m.Reregister {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ExecuteQueryRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExecuteQueryRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExecuteQueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Analyze {
		i--
		if m.Analyze {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Plan != nil {
		{
			size, err := m.Plan.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.QueryID != nil {
		{
			size, err := m.QueryID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RegisterTracepointRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RegisterTracepointRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RegisterTracepointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.TracepointDeployment != nil {
		{
			size, err := m.TracepointDeployment.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TracepointInfoUpdate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TracepointInfoUpdate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointInfoUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AgentID != nil {
		{
			size, err := m.AgentID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.State != 0 {
		i = encodeVarintMessages(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x10
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveTracepointRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RemoveTracepointRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveTracepointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessages(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ConfigUpdateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConfigUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConfigUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintMessages(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintMessages(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MetricsMessage) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MetricsMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetricsMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PodName) > 0 {
		i -= len(m.PodName)
		copy(dAtA[i:], m.PodName)
		i = encodeVarintMessages(dAtA, i, uint64(len(m.PodName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PromMetricsText) > 0 {
		i -= len(m.PromMetricsText)
		copy(dAtA[i:], m.PromMetricsText)
		i = encodeVarintMessages(dAtA, i, uint64(len(m.PromMetricsText)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintMessages(dAtA []byte, offset int, v uint64) int {
	offset -= sovMessages(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *VizierMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Msg != nil {
		n += m.Msg.Size()
	}
	return n
}

func (m *VizierMessage_RegisterAgentRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RegisterAgentRequest != nil {
		l = m.RegisterAgentRequest.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *VizierMessage_RegisterAgentResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RegisterAgentResponse != nil {
		l = m.RegisterAgentResponse.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *VizierMessage_Heartbeat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Heartbeat != nil {
		l = m.Heartbeat.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *VizierMessage_HeartbeatAck) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HeartbeatAck != nil {
		l = m.HeartbeatAck.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *VizierMessage_HeartbeatNack) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HeartbeatNack != nil {
		l = m.HeartbeatNack.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *VizierMessage_ExecuteQueryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ExecuteQueryRequest != nil {
		l = m.ExecuteQueryRequest.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *VizierMessage_TracepointMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TracepointMessage != nil {
		l = m.TracepointMessage.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *VizierMessage_ConfigUpdateMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ConfigUpdateMessage != nil {
		l = m.ConfigUpdateMessage.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *VizierMessage_K8SMetadataMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.K8SMetadataMessage != nil {
		l = m.K8SMetadataMessage.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *TracepointMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Msg != nil {
		n += m.Msg.Size()
	}
	return n
}

func (m *TracepointMessage_TracepointInfoUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TracepointInfoUpdate != nil {
		l = m.TracepointInfoUpdate.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *TracepointMessage_RemoveTracepointRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RemoveTracepointRequest != nil {
		l = m.RemoveTracepointRequest.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *TracepointMessage_RegisterTracepointRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RegisterTracepointRequest != nil {
		l = m.RegisterTracepointRequest.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *ConfigUpdateMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Msg != nil {
		n += m.Msg.Size()
	}
	return n
}

func (m *ConfigUpdateMessage_ConfigUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ConfigUpdateRequest != nil {
		l = m.ConfigUpdateRequest.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *K8SMetadataMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Msg != nil {
		n += m.Msg.Size()
	}
	return n
}

func (m *K8SMetadataMessage_K8SMetadataUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.K8SMetadataUpdate != nil {
		l = m.K8SMetadataUpdate.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *K8SMetadataMessage_MissingK8SMetadataRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MissingK8SMetadataRequest != nil {
		l = m.MissingK8SMetadataRequest.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *K8SMetadataMessage_MissingK8SMetadataResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MissingK8SMetadataResponse != nil {
		l = m.MissingK8SMetadataResponse.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}
func (m *RegisterAgentRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Info != nil {
		l = m.Info.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	if m.ASID != 0 {
		n += 1 + sovMessages(uint64(m.ASID))
	}
	return n
}

func (m *RegisterAgentResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ASID != 0 {
		n += 1 + sovMessages(uint64(m.ASID))
	}
	return n
}

func (m *AgentDataInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MetadataInfo != nil {
		l = m.MetadataInfo.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}

func (m *AgentUpdateInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Schema) > 0 {
		for _, e := range m.Schema {
			l = e.Size()
			n += 1 + l + sovMessages(uint64(l))
		}
	}
	if len(m.ProcessCreated) > 0 {
		for _, e := range m.ProcessCreated {
			l = e.Size()
			n += 1 + l + sovMessages(uint64(l))
		}
	}
	if len(m.ProcessTerminated) > 0 {
		for _, e := range m.ProcessTerminated {
			l = e.Size()
			n += 1 + l + sovMessages(uint64(l))
		}
	}
	if m.DoesUpdateSchema {
		n += 2
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}

func (m *Heartbeat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AgentID != nil {
		l = m.AgentID.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	if m.Time != 0 {
		n += 1 + sovMessages(uint64(m.Time))
	}
	if m.UpdateInfo != nil {
		l = m.UpdateInfo.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	if m.SequenceNumber != 0 {
		n += 1 + sovMessages(uint64(m.SequenceNumber))
	}
	return n
}

func (m *MetadataUpdateInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ServiceCIDR)
	if l > 0 {
		n += 1 + l + sovMessages(uint64(l))
	}
	if len(m.PodCIDRs) > 0 {
		for _, s := range m.PodCIDRs {
			l = len(s)
			n += 1 + l + sovMessages(uint64(l))
		}
	}
	return n
}

func (m *HeartbeatAck) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Time != 0 {
		n += 1 + sovMessages(uint64(m.Time))
	}
	if m.SequenceNumber != 0 {
		n += 1 + sovMessages(uint64(m.SequenceNumber))
	}
	if m.UpdateInfo != nil {
		l = m.UpdateInfo.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}

func (m *HeartbeatNack) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Reregister {
		n += 2
	}
	return n
}

func (m *ExecuteQueryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.QueryID != nil {
		l = m.QueryID.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	if m.Plan != nil {
		l = m.Plan.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	if m.Analyze {
		n += 2
	}
	return n
}

func (m *RegisterTracepointRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TracepointDeployment != nil {
		l = m.TracepointDeployment.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}

func (m *TracepointInfoUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovMessages(uint64(m.State))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	if m.AgentID != nil {
		l = m.AgentID.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}

func (m *RemoveTracepointRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}

func (m *ConfigUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovMessages(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}

func (m *MetricsMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PromMetricsText)
	if l > 0 {
		n += 1 + l + sovMessages(uint64(l))
	}
	l = len(m.PodName)
	if l > 0 {
		n += 1 + l + sovMessages(uint64(l))
	}
	return n
}

func sovMessages(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMessages(x uint64) (n int) {
	return sovMessages(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *VizierMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VizierMessage{`,
		`Msg:` + fmt.Sprintf("%v", this.Msg) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VizierMessage_RegisterAgentRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VizierMessage_RegisterAgentRequest{`,
		`RegisterAgentRequest:` + strings.Replace(fmt.Sprintf("%v", this.RegisterAgentRequest), "RegisterAgentRequest", "RegisterAgentRequest", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VizierMessage_RegisterAgentResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VizierMessage_RegisterAgentResponse{`,
		`RegisterAgentResponse:` + strings.Replace(fmt.Sprintf("%v", this.RegisterAgentResponse), "RegisterAgentResponse", "RegisterAgentResponse", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VizierMessage_Heartbeat) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VizierMessage_Heartbeat{`,
		`Heartbeat:` + strings.Replace(fmt.Sprintf("%v", this.Heartbeat), "Heartbeat", "Heartbeat", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VizierMessage_HeartbeatAck) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VizierMessage_HeartbeatAck{`,
		`HeartbeatAck:` + strings.Replace(fmt.Sprintf("%v", this.HeartbeatAck), "HeartbeatAck", "HeartbeatAck", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VizierMessage_HeartbeatNack) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VizierMessage_HeartbeatNack{`,
		`HeartbeatNack:` + strings.Replace(fmt.Sprintf("%v", this.HeartbeatNack), "HeartbeatNack", "HeartbeatNack", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VizierMessage_ExecuteQueryRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VizierMessage_ExecuteQueryRequest{`,
		`ExecuteQueryRequest:` + strings.Replace(fmt.Sprintf("%v", this.ExecuteQueryRequest), "ExecuteQueryRequest", "ExecuteQueryRequest", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VizierMessage_TracepointMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VizierMessage_TracepointMessage{`,
		`TracepointMessage:` + strings.Replace(fmt.Sprintf("%v", this.TracepointMessage), "TracepointMessage", "TracepointMessage", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VizierMessage_ConfigUpdateMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VizierMessage_ConfigUpdateMessage{`,
		`ConfigUpdateMessage:` + strings.Replace(fmt.Sprintf("%v", this.ConfigUpdateMessage), "ConfigUpdateMessage", "ConfigUpdateMessage", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VizierMessage_K8SMetadataMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VizierMessage_K8SMetadataMessage{`,
		`K8SMetadataMessage:` + strings.Replace(fmt.Sprintf("%v", this.K8SMetadataMessage), "K8SMetadataMessage", "K8SMetadataMessage", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TracepointMessage{`,
		`Msg:` + fmt.Sprintf("%v", this.Msg) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointMessage_TracepointInfoUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TracepointMessage_TracepointInfoUpdate{`,
		`TracepointInfoUpdate:` + strings.Replace(fmt.Sprintf("%v", this.TracepointInfoUpdate), "TracepointInfoUpdate", "TracepointInfoUpdate", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointMessage_RemoveTracepointRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TracepointMessage_RemoveTracepointRequest{`,
		`RemoveTracepointRequest:` + strings.Replace(fmt.Sprintf("%v", this.RemoveTracepointRequest), "RemoveTracepointRequest", "RemoveTracepointRequest", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointMessage_RegisterTracepointRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TracepointMessage_RegisterTracepointRequest{`,
		`RegisterTracepointRequest:` + strings.Replace(fmt.Sprintf("%v", this.RegisterTracepointRequest), "RegisterTracepointRequest", "RegisterTracepointRequest", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ConfigUpdateMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ConfigUpdateMessage{`,
		`Msg:` + fmt.Sprintf("%v", this.Msg) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ConfigUpdateMessage_ConfigUpdateRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ConfigUpdateMessage_ConfigUpdateRequest{`,
		`ConfigUpdateRequest:` + strings.Replace(fmt.Sprintf("%v", this.ConfigUpdateRequest), "ConfigUpdateRequest", "ConfigUpdateRequest", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *K8SMetadataMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&K8SMetadataMessage{`,
		`Msg:` + fmt.Sprintf("%v", this.Msg) + `,`,
		`}`,
	}, "")
	return s
}
func (this *K8SMetadataMessage_K8SMetadataUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&K8SMetadataMessage_K8SMetadataUpdate{`,
		`K8SMetadataUpdate:` + strings.Replace(fmt.Sprintf("%v", this.K8SMetadataUpdate), "ResourceUpdate", "metadatapb.ResourceUpdate", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *K8SMetadataMessage_MissingK8SMetadataRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&K8SMetadataMessage_MissingK8SMetadataRequest{`,
		`MissingK8SMetadataRequest:` + strings.Replace(fmt.Sprintf("%v", this.MissingK8SMetadataRequest), "MissingK8SMetadataRequest", "metadatapb.MissingK8SMetadataRequest", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *K8SMetadataMessage_MissingK8SMetadataResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&K8SMetadataMessage_MissingK8SMetadataResponse{`,
		`MissingK8SMetadataResponse:` + strings.Replace(fmt.Sprintf("%v", this.MissingK8SMetadataResponse), "MissingK8SMetadataResponse", "metadatapb.MissingK8SMetadataResponse", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RegisterAgentRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RegisterAgentRequest{`,
		`Info:` + strings.Replace(fmt.Sprintf("%v", this.Info), "AgentInfo", "agentpb.AgentInfo", 1) + `,`,
		`ASID:` + fmt.Sprintf("%v", this.ASID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RegisterAgentResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RegisterAgentResponse{`,
		`ASID:` + fmt.Sprintf("%v", this.ASID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AgentDataInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AgentDataInfo{`,
		`MetadataInfo:` + strings.Replace(fmt.Sprintf("%v", this.MetadataInfo), "MetadataInfo", "distributedpb.MetadataInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AgentUpdateInfo) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForSchema := "[]*TableInfo{"
	for _, f := range this.Schema {
		repeatedStringForSchema += strings.Replace(fmt.Sprintf("%v", f), "TableInfo", "storepb.TableInfo", 1) + ","
	}
	repeatedStringForSchema += "}"
	repeatedStringForProcessCreated := "[]*ProcessCreated{"
	for _, f := range this.ProcessCreated {
		repeatedStringForProcessCreated += strings.Replace(fmt.Sprintf("%v", f), "ProcessCreated", "metadatapb.ProcessCreated", 1) + ","
	}
	repeatedStringForProcessCreated += "}"
	repeatedStringForProcessTerminated := "[]*ProcessTerminated{"
	for _, f := range this.ProcessTerminated {
		repeatedStringForProcessTerminated += strings.Replace(fmt.Sprintf("%v", f), "ProcessTerminated", "metadatapb.ProcessTerminated", 1) + ","
	}
	repeatedStringForProcessTerminated += "}"
	s := strings.Join([]string{`&AgentUpdateInfo{`,
		`Schema:` + repeatedStringForSchema + `,`,
		`ProcessCreated:` + repeatedStringForProcessCreated + `,`,
		`ProcessTerminated:` + repeatedStringForProcessTerminated + `,`,
		`DoesUpdateSchema:` + fmt.Sprintf("%v", this.DoesUpdateSchema) + `,`,
		`Data:` + strings.Replace(this.Data.String(), "AgentDataInfo", "AgentDataInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Heartbeat) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Heartbeat{`,
		`AgentID:` + strings.Replace(fmt.Sprintf("%v", this.AgentID), "UUID", "uuidpb.UUID", 1) + `,`,
		`Time:` + fmt.Sprintf("%v", this.Time) + `,`,
		`UpdateInfo:` + strings.Replace(this.UpdateInfo.String(), "AgentUpdateInfo", "AgentUpdateInfo", 1) + `,`,
		`SequenceNumber:` + fmt.Sprintf("%v", this.SequenceNumber) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetadataUpdateInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetadataUpdateInfo{`,
		`ServiceCIDR:` + fmt.Sprintf("%v", this.ServiceCIDR) + `,`,
		`PodCIDRs:` + fmt.Sprintf("%v", this.PodCIDRs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HeartbeatAck) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HeartbeatAck{`,
		`Time:` + fmt.Sprintf("%v", this.Time) + `,`,
		`SequenceNumber:` + fmt.Sprintf("%v", this.SequenceNumber) + `,`,
		`UpdateInfo:` + strings.Replace(this.UpdateInfo.String(), "MetadataUpdateInfo", "MetadataUpdateInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HeartbeatNack) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HeartbeatNack{`,
		`Reregister:` + fmt.Sprintf("%v", this.Reregister) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExecuteQueryRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExecuteQueryRequest{`,
		`QueryID:` + strings.Replace(fmt.Sprintf("%v", this.QueryID), "UUID", "uuidpb.UUID", 1) + `,`,
		`Plan:` + strings.Replace(fmt.Sprintf("%v", this.Plan), "Plan", "planpb.Plan", 1) + `,`,
		`Analyze:` + fmt.Sprintf("%v", this.Analyze) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RegisterTracepointRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RegisterTracepointRequest{`,
		`TracepointDeployment:` + strings.Replace(fmt.Sprintf("%v", this.TracepointDeployment), "TracepointDeployment", "logicalpb.TracepointDeployment", 1) + `,`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointInfoUpdate) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TracepointInfoUpdate{`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`State:` + fmt.Sprintf("%v", this.State) + `,`,
		`Status:` + strings.Replace(fmt.Sprintf("%v", this.Status), "Status", "statuspb.Status", 1) + `,`,
		`AgentID:` + strings.Replace(fmt.Sprintf("%v", this.AgentID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RemoveTracepointRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RemoveTracepointRequest{`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ConfigUpdateRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ConfigUpdateRequest{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetricsMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetricsMessage{`,
		`PromMetricsText:` + fmt.Sprintf("%v", this.PromMetricsText) + `,`,
		`PodName:` + fmt.Sprintf("%v", this.PodName) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringMessages(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *VizierMessage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: VizierMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VizierMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisterAgentRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RegisterAgentRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &VizierMessage_RegisterAgentRequest{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisterAgentResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RegisterAgentResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &VizierMessage_RegisterAgentResponse{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Heartbeat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Heartbeat{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &VizierMessage_Heartbeat{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeartbeatAck", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HeartbeatAck{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &VizierMessage_HeartbeatAck{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeartbeatNack", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &HeartbeatNack{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &VizierMessage_HeartbeatNack{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecuteQueryRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ExecuteQueryRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &VizierMessage_ExecuteQueryRequest{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TracepointMessage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TracepointMessage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &VizierMessage_TracepointMessage{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigUpdateMessage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ConfigUpdateMessage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &VizierMessage_ConfigUpdateMessage{v}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field K8SMetadataMessage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &K8SMetadataMessage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &VizierMessage_K8SMetadataMessage{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TracepointMessage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TracepointMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TracepointInfoUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TracepointInfoUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &TracepointMessage_TracepointInfoUpdate{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemoveTracepointRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RemoveTracepointRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &TracepointMessage_RemoveTracepointRequest{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisterTracepointRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RegisterTracepointRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &TracepointMessage_RegisterTracepointRequest{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConfigUpdateMessage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConfigUpdateMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfigUpdateMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigUpdateRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ConfigUpdateRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &ConfigUpdateMessage_ConfigUpdateRequest{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *K8SMetadataMessage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: K8sMetadataMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: K8sMetadataMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field K8SMetadataUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &metadatapb.ResourceUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &K8SMetadataMessage_K8SMetadataUpdate{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MissingK8SMetadataRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &metadatapb.MissingK8SMetadataRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &K8SMetadataMessage_MissingK8SMetadataRequest{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MissingK8SMetadataResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &metadatapb.MissingK8SMetadataResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Msg = &K8SMetadataMessage_MissingK8SMetadataResponse{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterAgentRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RegisterAgentRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterAgentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Info == nil {
				m.Info = &agentpb.AgentInfo{}
			}
			if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ASID", wireType)
			}
			m.ASID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ASID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterAgentResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RegisterAgentResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterAgentResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ASID", wireType)
			}
			m.ASID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ASID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentDataInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentDataInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentDataInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetadataInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MetadataInfo == nil {
				m.MetadataInfo = &distributedpb.MetadataInfo{}
			}
			if err := m.MetadataInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentUpdateInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentUpdateInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentUpdateInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Schema = append(m.Schema, &storepb.TableInfo{})
			if err := m.Schema[len(m.Schema)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessCreated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProcessCreated = append(m.ProcessCreated, &metadatapb.ProcessCreated{})
			if err := m.ProcessCreated[len(m.ProcessCreated)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessTerminated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProcessTerminated = append(m.ProcessTerminated, &metadatapb.ProcessTerminated{})
			if err := m.ProcessTerminated[len(m.ProcessTerminated)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DoesUpdateSchema", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DoesUpdateSchema = bool(v != 0)
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &AgentDataInfo{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Heartbeat) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Heartbeat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Heartbeat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgentID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AgentID == nil {
				m.AgentID = &uuidpb.UUID{}
			}
			if err := m.AgentID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UpdateInfo == nil {
				m.UpdateInfo = &AgentUpdateInfo{}
			}
			if err := m.UpdateInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SequenceNumber", wireType)
			}
			m.SequenceNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SequenceNumber |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetadataUpdateInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MetadataUpdateInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetadataUpdateInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceCIDR", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceCIDR = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodCIDRs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodCIDRs = append(m.PodCIDRs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HeartbeatAck) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HeartbeatAck: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeartbeatAck: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			m.Time = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Time |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SequenceNumber", wireType)
			}
			m.SequenceNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SequenceNumber |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UpdateInfo == nil {
				m.UpdateInfo = &MetadataUpdateInfo{}
			}
			if err := m.UpdateInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HeartbeatNack) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HeartbeatNack: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeartbeatNack: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reregister", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Reregister = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExecuteQueryRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExecuteQueryRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExecuteQueryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.QueryID == nil {
				m.QueryID = &uuidpb.UUID{}
			}
			if err := m.QueryID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Plan", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Plan == nil {
				m.Plan = &planpb.Plan{}
			}
			if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Analyze", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Analyze = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterTracepointRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RegisterTracepointRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterTracepointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TracepointDeployment", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TracepointDeployment == nil {
				m.TracepointDeployment = &logicalpb.TracepointDeployment{}
			}
			if err := m.TracepointDeployment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &uuidpb.UUID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TracepointInfoUpdate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TracepointInfoUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointInfoUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &uuidpb.UUID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= statuspb.LifeCycleState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &statuspb.Status{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgentID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AgentID == nil {
				m.AgentID = &uuidpb.UUID{}
			}
			if err := m.AgentID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RemoveTracepointRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RemoveTracepointRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoveTracepointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &uuidpb.UUID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConfigUpdateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConfigUpdateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfigUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MetricsMessage) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MetricsMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetricsMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PromMetricsText", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PromMetricsText = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMessages
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessages
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessages(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthMessages
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMessages(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowMessages
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMessages
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthMessages
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMessages
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMessages
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMessages        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMessages          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMessages = fmt.Errorf("proto: unexpected end of group")
)
